﻿using System;
using System.CodeDom.Compiler;
using System.Collections.Generic;
using System.Reflection.Emit;

namespace Teal.Compiler {

    #region 节点

    /// <summary>
    /// 所有语法树节点的抽象基类。
    /// </summary>
    public abstract partial class Node {

        /// <summary>
        /// 生成当前节点的代码。
        /// </summary>
        /// <param name="context">用于存储所有生成数据的上下文对象。</param>
        public virtual void emit(EmitContext context) {
            throw new NotSupportedException();
        }

    }

    ///// <summary>
    ///// 表示一个泛型参数。
    ///// </summary>
    //public partial class GenericTypeParameter : Node {

    //    /// <summary>
    //    /// 表示一个泛型约束表达式。
    //    /// </summary>
    //    public partial class ConstraintExpression : Expression {

    //    }

    //}

    #endregion

    //#region 表达式

    //#region Expression

    ///// <summary>
    ///// 所有表达式的抽象基类。
    ///// </summary>
    //public abstract partial class Expression : Node, ISymbol {

    //    private partial class EmptyExpression : Expression {

    //    }

    //}

    ///// <summary>
    ///// 表示一个变量定义。
    ///// </summary>
    //public partial class Variable : Expression, ISymbol {

    //    /// <summary>
    //    /// 获取当前引用的原始信息。
    //    /// </summary>
    //    public System.Reflection.Emit.LocalBuilder variableInfo;

    //    /// <summary>
    //    /// 生成当前节点的代码。
    //    /// </summary>
    //    /// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //    public override void emit(EmitContext context) {

    //        //variableInfo = context.createVariable(resolvedType.typeInfo, name.value);

    //        //// 没有初始值，不需要处理。
    //        //if (initialiser != null) {
    //        //    initialiser.emit(context);
    //        //    emitStore(context);
    //        //}

    //    }

    //    ///// <summary>
    //    ///// 生成存储到当前变量的代码。
    //    ///// </summary>
    //    ///// <param name="context"></param>
    //    //public void emitStore(EmitContext context) {
    //    //    if (constraint != null) {
    //    //        // todo:  提交约束代码。

    //    //        Compiler.notImplement(this);
    //    //    }
    //    //    context.emitStoreVariable(variableInfo);
    //    //}

    //}

    ///// <summary>
    ///// 表示一个函数参数。
    ///// </summary>
    //public partial class Parameter : Variable, ISymbol {

    //}

    //#endregion

    //#region ResolvedExpression

    ///// <summary>
    ///// 所有编译器动态生成的表达式的抽象基类。
    ///// </summary>
    //public abstract partial class ResolvedExpression : Expression {

    //}

    ///// <summary>
    ///// 表示单目操作。
    ///// </summary>
    //public sealed partial class UnaryOperation : ResolvedExpression {

    //    /// <summary>
    //    /// 生成当前节点的代码。
    //    /// </summary>
    //    /// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //    public override void emit(EmitContext context) {
    //        operand.emit(context);
    //        context.emitConvertToInt32();
    //    }

    //}

    ///// <summary>
    ///// 表示单目操作。
    ///// </summary>
    //public sealed class BinaryOperation : ResolvedExpression {

    //    /// <summary>
    //    /// 生成当前节点的代码。
    //    /// </summary>
    //    /// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //    public override void emit(EmitContext context) {
    //        //    operand.emit(context);
    //        context.emitConvertToInt32();
    //    }

    //}

    //public partial class TypeOperationExpression : ResolvedExpression {

    //}

    ///// <summary>
    ///// 表示一个操作引用的表达式。
    ///// </summary>
    //public partial class ReferenceExpression : ResolvedExpression {

    //    /// <summary>
    //    /// 生成当前节点的代码。
    //    /// </summary>
    //    /// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //    public override void emit(EmitContext context) {

    //    }

    //}

    //public abstract partial class VariableExpression : ReferenceExpression {

    //}

    //public sealed partial class LoadVariableExpression : VariableExpression {

    //}

    //public sealed partial class StoreVariableExpression : VariableExpression {

    //}

    //public sealed partial class AddressOfVariableExpression : VariableExpression {

    //}

    ///// <summary>
    ///// 表示从字段读取值。
    ///// </summary>
    //public sealed partial class LoadFieldExpression : ReferenceExpression {

    //}

    ///// <summary>
    ///// 表示从字段读取值。
    ///// </summary>
    //public sealed partial class StoreFieldExpression : ReferenceExpression {

    //}

    ///// <summary>
    ///// 表示从字段读取值。
    ///// </summary>
    //public sealed partial class LoadPropertyExpression : ReferenceExpression {

    //}

    ///// <summary>
    ///// 表示从字段读取值。
    ///// </summary>
    //public sealed partial class StorePropertyExpression : ReferenceExpression {

    //}

    ///// <summary>
    ///// 所有类型转换表达式的抽象基类。
    ///// </summary>
    //public abstract partial class Convertion : ResolvedExpression {

    //}

    ///// <summary>
    ///// 表示一个隐式类型操作。
    ///// </summary>
    //public sealed partial class CastConvertion : Convertion {

    //}

    ///// <summary>
    ///// 表示一个转为 int 类型的操作。
    ///// </summary>
    //public sealed partial class IntConvertion : Convertion {

    //}

    ///// <summary>
    ///// 表示一个转为 sbyte 类型的操作。
    ///// </summary>
    //public sealed partial class SByteConvertion : Convertion {

    //}

    ///// <summary>
    ///// 表示一个转为 byte 类型的操作。
    ///// </summary>
    //public sealed partial class ByteConvertion : Convertion {

    //}

    ///// <summary>
    ///// 表示一个转为 char 类型的操作。
    ///// </summary>
    //public sealed partial class CharConvertion : Convertion {

    //}

    ///// <summary>
    ///// 表示一个转为 short 类型的操作。
    ///// </summary>
    //public sealed partial class ShortConvertion : Convertion {

    //}

    ///// <summary>
    ///// 表示一个转为 ushort 类型的操作。
    ///// </summary>
    //public sealed partial class UShortConvertion : Convertion {

    //}

    ///// <summary>
    ///// 表示一个转为 uint 类型的操作。
    ///// </summary>
    //public sealed partial class UIntConvertion : Convertion {

    //}

    ///// <summary>
    ///// 表示一个转为 long 类型的操作。
    ///// </summary>
    //public sealed partial class LongConvertion : Convertion {

    //}

    ///// <summary>
    ///// 表示一个转为 ulong 类型的操作。
    ///// </summary>
    //public sealed partial class ULongConvertion : Convertion {

    //}

    ///// <summary>
    ///// 表示一个转为 float 类型的操作。
    ///// </summary>
    //public sealed partial class FloatConvertion : Convertion {

    //}

    ///// <summary>
    ///// 表示一个转为 double 类型的操作。
    ///// </summary>
    //public sealed partial class DoubleConvertion : Convertion {

    //}

    //#endregion

    //#region Literals

    ///// <summary>
    ///// 表示常量表达式。
    ///// </summary>
    //public partial class SpecialLiteral : Expression {

    //    /// <summary>
    //    /// 生成当前节点的代码。
    //    /// </summary>
    //    /// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //    public override void emit(EmitContext context) {
    //        switch (type) {
    //            case TokenType.@true:
    //                context.emitLoadTrue();
    //                break;
    //            case TokenType.@false:
    //                context.emitLoadFalse();
    //                break;
    //        }
    //    }


    //}

    ///// <summary>
    ///// 表示一个字符串常量。
    ///// </summary>
    //public partial class StringLiteral : Expression {

    //    /// <summary>
    //    /// 生成当前节点的代码。
    //    /// </summary>
    //    /// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //    public override void emit(EmitContext context) {
    //        context.emitLoadString(value);
    //    }

    //}

    ///// <summary>
    ///// 表示一个整数常量。
    ///// </summary>
    //public partial class IntLiteral : Expression {

    //    /// <summary>
    //    /// 生成当前节点的代码。
    //    /// </summary>
    //    /// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //    public override void emit(EmitContext context) {
    //        context.emitLoadInt32(value);
    //    }

    //}

    ///// <summary>
    ///// 表示一个浮点数常量。
    ///// </summary>
    //public partial class FloatLiteral : Expression {

    //    /// <summary>
    //    /// 生成当前节点的代码。
    //    /// </summary>
    //    /// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //    public override void emit(EmitContext context) {
    //        context.emitLoadDouble(value);
    //    }

    //}

    ///// <summary>
    ///// 表示一个列表表达式。
    ///// </summary>
    //public partial class ListLiteral : Expression {

    //}

    ///// <summary>
    ///// 表示一个对象常量。
    ///// </summary>
    //public partial class DictLiteral : Expression {

    //}

    ///// <summary>
    ///// 表示一个区间表达式。
    ///// </summary>
    //public partial class RangeLiteral : Expression {

    //    public override TypeReference resolvedType {
    //        get {
    //            return PredefinedTypes.range;
    //        }
    //    }

    //    /// <summary>
    //    /// 将当前表达式作为值解析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析信息的上下文对象。</param>
    //    /// <returns>
    //    /// 返回解析后的新表达式，它的所有子表达式都已经被解析。如果解析出现错误则返回 null 。
    //    /// </returns>
    //    /// <exception cref="System.NotImplementedException"></exception>
    //    public override Expression resolveAsValue(ResolveContext context) {
    //        start = start.resolveAsValue(context);
    //        end = end.resolveAsValue(context);
    //        if (start == null || end == null) {
    //            return null;
    //        }
    //        return this;
    //    }

    //}

    ///// <summary>
    ///// 表示一个函数表达式。
    ///// </summary>
    //public partial class LambdaLiteral : Expression {


    //    TypeReference _resolvedType;

    //    public override TypeReference resolvedType {
    //        get {
    //            return _resolvedType;
    //        }
    //    }

    //    /// <summary>
    //    /// 将当前表达式作为值解析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析信息的上下文对象。</param>
    //    /// <returns>
    //    /// 返回解析后的新表达式，它的所有子表达式都已经被解析。如果解析出现错误则返回 null 。
    //    /// </returns>
    //    /// <exception cref="System.NotImplementedException"></exception>
    //    public override Expression resolveAsValue(ResolveContext context) {
    //        throw new NotImplementedException();
    //    }

    //}

    //#endregion

    //#region Identfier

    ///// <summary>
    ///// 表示一个标识符。
    ///// </summary>
    //public partial class Identifier : Expression {

    //}

    ///// <summary>
    ///// 表示一个魔法变量。
    ///// </summary>
    //public partial class MagicVariable : Identifier {

    //    /// <summary>
    //    /// 将当前表达式解析为一个符号。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析信息的上下文对象。</param>
    //    /// <param name="symbolUsage">当前引用的使用场景。</param>
    //    /// <returns>返回解析后的引用。如果解析出现错误则返回 null 。</returns>
    //    public override ISymbol resolveAsSymbol(ResolveContext context, ReferenceUsage symbolUsage) {
    //        //    TODO
    //        return base.resolveAsSymbol(context, symbolUsage);
    //    }

    //}

    //#endregion

    //#region ShimExpressions

    ///// <summary>
    ///// 表示一个可以独立使用的表达式。
    ///// </summary>
    //public partial class StatementExpression : Expression {

    //    /// <summary>
    //    /// 生成当前节点的代码。
    //    /// </summary>
    //    /// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //    /// <exception cref="System.NotImplementedException"></exception>
    //    public override void emit(EmitContext context) {
    //        throw new NotSupportedException();
    //    }

    //}

    ///// <summary>
    ///// 表示一个将计算为 bool 的表达式。
    ///// </summary>
    //public partial class BooleanExpression : StatementExpression {


    //}

    ///// <summary>
    ///// 表示一个括号表达式。
    ///// </summary>
    //public partial class ParenthesizedExpression : Expression {

    //}

    ///// <summary>
    ///// 表示一个三元条件表达式。
    ///// </summary>
    //public partial class ConditionalExpression : Expression {

    //    ////public override void Emit(EmitContext context) {
    //    ////	Label false_target = context.DefineLabel();
    //    ////	Label end_target = context.DefineLabel();

    //    ////	condition.EmitBranchable(context, false_target, false);
    //    ////	thenExpression.Emit(context);

    //    ////	//
    //    ////	// Verifier doesn't support interface merging. When there are two types on
    //    ////	// the stack without common type hint and the common type is an interface.
    //    ////	// Use temporary local to give verifier hint on what type to unify the stack
    //    ////	//
    //    ////	if (resovledType.IsInterface && thenExpression is EmptyCast && elseExpression is EmptyCast) {
    //    ////		var temp = context.GetTemporaryLocal(resovledType);
    //    ////		context.Emit(OpCodes.Stloc, temp);
    //    ////		context.Emit(OpCodes.Ldloc, temp);
    //    ////		context.FreeTemporaryLocal(temp, resovledType);
    //    ////	}

    //    ////	context.Emit(OpCodes.Br, end_target);
    //    ////	context.MarkLabel(false_target);
    //    ////	elseExpression.Emit(context);
    //    ////	context.MarkLabel(end_target);
    //    ////}


    //}

    //#endregion

    //#region TypeExpressions

    ///// <summary>
    ///// 表示一个泛型表达式。
    ///// </summary>
    ///// <remarks>
    ///// 泛型表达式是由一个 Identifier 和泛型参数组成的表达式，在很多地方它可以代替 Identifier 作为一个整体。
    ///// 如表达式 A.B&lt;int&gt; 最后解析结果是一个 PropertyCallExpression(target: Identifier("A"), argument: GenericExpression(baseType: Identifier("B"), genericArguments:[Identifier("int")])) 。
    ///// </remarks>
    //public partial class GenericTypeExpression : Expression {

    //}

    ///// <summary>
    ///// 表示一个数组类型表达式。
    ///// </summary>
    //public partial class ArrayTypeExpression : Expression {

    //}

    ///// <summary>
    ///// 表示一个指针表达式。
    ///// </summary>
    //public partial class PtrTypeExpression : Expression {

    //}

    //#endregion

    //#region CallExpression

    ///// <summary>
    ///// 表示一个成员调用表达式。
    ///// </summary>
    //public partial class MemberCallExpression : Expression {

    //}

    ///// <summary>
    ///// 表示一个函数调用表达式。
    ///// </summary>
    //public partial class FuncCallExpression : Expression {

    //    /// <summary>
    //    /// 生成当前节点的代码。
    //    /// </summary>
    //    /// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //    public override void emit(EmitContext context) {
    //        target.emit(context);
    //        base.emit(context);
    //    }


    //}

    ///// <summary>
    ///// 表示一个 new 表达式。
    ///// </summary>
    //public partial class NewExpression : FuncCallExpression {

    //}

    ///// <summary>
    ///// 表示一个索引调用表达式。
    ///// </summary>
    //public partial class IndexCallExpression : FuncCallExpression {




    //    ///// <summary>
    //    ///// 将当前表达式作为右值解析。
    //    ///// </summary>
    //    ///// <param name="context">用于存储所有解析信息的上下文对象。</param>
    //    ///// <returns>
    //    ///// 返回解析后的新表达式，它的所有子表达式都已经被解析。如果解析出现错误则返回 null 。
    //    ///// </returns>
    //    //public override Expression resolveAsValue(ResolveContext context) {
    //    //    Compiler.notImplement(this);
    //    //    return null;
    //    //    //return base.resolveAsValue(context);
    //    //}


    //    //#region 生成


    //}

    ///// <summary>
    ///// 表示一个链式成员访问表达式。
    ///// </summary>
    //public partial class ChainCallExpression : MemberCallExpression {




    //    ///// <summary>
    //    ///// 将当前表达式作为右值解析。
    //    ///// </summary>
    //    ///// <param name="context">用于存储所有解析信息的上下文对象。</param>
    //    ///// <returns>
    //    ///// 返回解析后的新表达式，它的所有子表达式都已经被解析。如果解析出现错误则返回 null 。
    //    ///// </returns>
    //    //public override Expression resolveAsValue(ResolveContext context) {
    //    //    Compiler.notImplement(this);
    //    //    return null;
    //    //    //return base.resolveAsValue(context);
    //    //}


    //    //#region 生成


    //}

    //#endregion

    //#region ArithmeticExpression

    ///// <summary>
    ///// 表示一个一元运算表达式。
    ///// </summary>
    //public partial class UnaryExpression : Expression {




    //    ///// <summary>
    //    ///// 获取当前表达式解析后的返回值类型。
    //    ///// </summary>
    //    //public override TypeReference resolvedType {
    //    //    get {
    //    //        return operand.resolvedType;
    //    //    }
    //    //}

    //    ///// <summary>
    //    ///// 将当前表达式作为右值解析。
    //    ///// </summary>
    //    ///// <param name="context">用于存储所有解析信息的上下文对象。</param>
    //    ///// <returns>返回解析后的新表达式，它的所有子表达式都已经被解析。如果解析出现错误则返回 null 。</returns>
    //    //public override Expression resolveAsValue(ResolveContext context) {
    //    //    switch (@operator) {
    //    //        case TokenType.not:
    //    //            return new UnaryOperation() {
    //    //                operand = operand.resolveAsBoolValue(context),
    //    //                opcodeType = OpCodeType.ceq_i32_0,
    //    //                returnType = PredefinedTypes.@bool,
    //    //            };

    //    //        case TokenType.inc:
    //    //        case TokenType.dec:
    //    //            return resolveIncOrDec(context);

    //    //        case TokenType.add:
    //    //        case TokenType.sub:
    //    //            return resolveAddOrSub(context);

    //    //        case TokenType.@typeof:
    //    //        case TokenType.@sizeof:
    //    //            return resolveTypeOrSizeOf(context);

    //    //        case TokenType.varAnd:
    //    //            return resolveAddressOf(context);
    //    //        case TokenType.mul:
    //    //            return resolveValueOf(context);

    //    //        case TokenType.await:
    //    //            Compiler.notImplement(this);
    //    //            return this;
    //    //        case TokenType.async:
    //    //            Compiler.notImplement(this);
    //    //            return this;

    //    //        case TokenType.runonce:
    //    //            Compiler.notImplement(this);
    //    //            return this;

    //    //        case TokenType.@checked:
    //    //            context.isChecked = true;
    //    //            return operand.resolveAsValue(context);
    //    //        case TokenType.@unchecked:
    //    //            context.isChecked = false;
    //    //            return operand.resolveAsValue(context);

    //    //        case TokenType.bitComplement:
    //    //            return this;
    //    //        default:
    //    //            throw new NotSupportedException();
    //    //    }
    //    //}

    //    //private Expression resolveValueOf(ResolveContext context) {
    //    //    Compiler.notImplement(this);
    //    //    return this;
    //    //}

    //    //private Expression resolveAddressOf(ResolveContext context) {

    //    //    Compiler.notImplement(this);
    //    //    return this;
    //    //}

    //    //private Expression resolveAddOrSub(ResolveContext context) {

    //    //    return ArithmeticExpressionResolver.resolve(context, operand, @operator);
    //    //}

    //    //Expression resolveIncOrDec(ResolveContext context) {

    //    //    // 目标表达式必须可赋值。
    //    //    var operandRef = operand.resolveAsSymbol(context, ReferenceUsage.getValue);
    //    //    if (operandRef == null) {
    //    //        return null;
    //    //    }

    //    //    // 解析目标表达式。
    //    //    Expression value = operandRef.getValue(context, operand);
    //    //    if (value == null) {
    //    //        return null;
    //    //    }

    //    //    // 解析用户自定义操作符重载。
    //    //    if (ArithmeticExpressionResolver.tryCallUserOperatorOverload(context, ref operand, @operator, 1)) {
    //    //        return this;
    //    //    }

    //    //    // 更新为 a = a + 1
    //    //    return operandRef.setValue(context, new BinaryExpression() {
    //    //        leftOperand = value,
    //    //        @operator = @operator == TokenType.inc ? TokenType.add : TokenType.sub,
    //    //        rightOperand = new IntLiteral() {
    //    //            value = 1
    //    //        }
    //    //    }.resolveAsValue(context), operand);

    //    //}

    //    //Expression resolveTypeOrSizeOf(ResolveContext context) {
    //    //    var member = operand.resolveAsMember(context.containerMemberDefinition, MemberUsage.typeDefinition);
    //    //    var type = member as TypeReference;
    //    //    if (type == null && member != null) {
    //    //        Compiler.error(1, String.Format("应输入类型（“{0}”是{1}，不是类型）", member.fullName, member.memberType.getReadableName()), this);
    //    //    }

    //    //    return new TypeOperationExpression() {
    //    //        startLocation = startLocation,
    //    //        @operator = @operator,
    //    //        operand = type,
    //    //        endLocation = endLocation
    //    //    };
    //    //}

    //    /////// <summary>
    //    /////// 将当前表达式作为右值解析。
    //    /////// </summary>
    //    /////// <param name="context">用于存储所有解析信息的上下文对象。</param>
    //    /////// <returns>
    //    /////// 返回解析后的新表达式，它的所有子表达式都已经被解析。如果解析出现错误则返回 null 。
    //    /////// </returns>
    //    ////public override Expression onResolveAsRValue(ResolveContext context) {

    //    ////	switch (@operator) {
    //    ////		case TokenType.Add:
    //    ////			break;
    //    ////		case TokenType.Sub:
    //    ////			break;
    //    ////		case TokenType.Not:
    //    ////			break;
    //    ////		case TokenType.Ref:
    //    ////			return ResolveAddressOf(context);
    //    ////	}


    //    ////	operand = operand._Resolve(context);
    //    ////	if (operand == null)
    //    ////		return null;

    //    ////	if (operand.resovledType.builtinType == PredefinedTypeReference.BuitinType.Dynamic) {
    //    ////		Arguments args = new Arguments(1);
    //    ////		args.Add(new Argument(operand));
    //    ////		return new DynamicUnaryConversion(GetOperatorExpressionTypeName(), args, startLocation)._Resolve(context);
    //    ////	}

    //    ////	if (operand.resovledType.IsNullableType)
    //    ////		return new Mono.CSharp.Nullable.LiftedUnaryOperator(Oper, operand, startLocation)._Resolve(context);

    //    ////	//
    //    ////	// Attempt to use a constant folding operation.
    //    ////	//
    //    ////	Constant cexpr = operand as Constant;
    //    ////	if (cexpr != null) {
    //    ////		cexpr = TryReduceConstant(context, cexpr);
    //    ////		if (cexpr != null)
    //    ////			return cexpr;
    //    ////	}

    //    ////	Expression expr = ResolveOperator(context, operand);
    //    ////	if (expr == null)
    //    ////		Error_OperatorCannotBeApplied(context, startLocation, OperName(Oper), operand.resovledType);

    //    ////	//
    //    ////	// Reduce unary operator on predefined types
    //    ////	//
    //    ////	if (expr == this && Oper == Operator.UnaryPlus)
    //    ////		return operand;

    //    ////	return expr;
    //    ////}

    //    ////protected override Expression DoResolve(ResolveContext context) {
    //    ////	if (Oper == Operator.AddressOf) {
    //    ////		return ResolveAddressOf(context);
    //    ////	}

    //    ////	operand = operand._Resolve(context);
    //    ////	if (operand == null)
    //    ////		return null;

    //    ////	if (operand.resovledType.builtinType == PredefinedTypeReference.BuitinType.Dynamic) {
    //    ////		Arguments args = new Arguments(1);
    //    ////		args.Add(new Argument(operand));
    //    ////		return new DynamicUnaryConversion(GetOperatorExpressionTypeName(), args, startLocation)._Resolve(context);
    //    ////	}

    //    ////	if (operand.resovledType.IsNullableType)
    //    ////		return new Mono.CSharp.Nullable.LiftedUnaryOperator(Oper, operand, startLocation)._Resolve(context);

    //    ////	//
    //    ////	// Attempt to use a constant folding operation.
    //    ////	//
    //    ////	Constant cexpr = operand as Constant;
    //    ////	if (cexpr != null) {
    //    ////		cexpr = TryReduceConstant(context, cexpr);
    //    ////		if (cexpr != null)
    //    ////			return cexpr;
    //    ////	}

    //    ////	Expression expr = ResolveOperator(context, operand);
    //    ////	if (expr == null)
    //    ////		Error_OperatorCannotBeApplied(context, startLocation, OperName(Oper), operand.resovledType);

    //    ////	//
    //    ////	// Reduce unary operator on predefined types
    //    ////	//
    //    ////	if (expr == this && Oper == Operator.UnaryPlus)
    //    ////		return operand;

    //    ////	return expr;
    //    ////}


    //    //#region 生成

    //    //public override void emit(EmitContext context) {
    //    //    switch (@operator) {
    //    //        case TokenType.add:
    //    //            operand.emit(context);
    //    //            break;
    //    //        case TokenType.sub:
    //    //            if (context.checkOverflow && operand.resolvedType != PredefinedTypes.@float && operand.resolvedType != PredefinedTypes.@double) {
    //    //                //if (context.HasSet(BuilderContext.Options.AsyncBody) && operand.ContainsEmitWithAwait())
    //    //                //	operand = operand.EmitToField(context);

    //    //                context.emitLoadInt32(0);
    //    //                if (operand.resolvedType == PredefinedTypes.@long)
    //    //                    context.emitConvertToUnsignedInt64();
    //    //                operand.emit(context);
    //    //                context.emitSubtractOverflow();
    //    //            } else {
    //    //                operand.emit(context);
    //    //                context.emitNegate();
    //    //            }

    //    //            break;
    //    //        case TokenType.not:
    //    //            operand.emit(context);
    //    //            context.emitLoadInt32(0);
    //    //            context.emitCompareEqual();
    //    //            break;
    //    //        case TokenType.inc:
    //    //            operand.emit(context);
    //    //            context.emitLoadInt32(1);
    //    //            context.emitAdd();
    //    //            break;
    //    //        case TokenType.dec:
    //    //            operand.emit(context);
    //    //            context.emitLoadInt32(-1);
    //    //            context.emitAdd();
    //    //            break;
    //    //        default:
    //    //            Compiler.notImplement(this);
    //    //            break;
    //    //    }
    //    //}

    //    ////protected void EmitOperator(EmitContext context, TypeReference type) {
    //    ////	switch (Oper) {
    //    ////		case Operator.UnaryPlus:
    //    ////			operand.Emit(context);
    //    ////			break;

    //    ////		case Operator.UnaryNegation:
    //    ////			if (context.HasSet(EmitContext.Options.CheckedScope) && !IsFloat(type)) {
    //    ////				if (context.HasSet(BuilderContext.Options.AsyncBody) && operand.ContainsEmitWithAwait())
    //    ////					operand = operand.EmitToField(context);

    //    ////				context.EmitInt(0);
    //    ////				if (type.builtinType == PredefinedTypeReference.BuitinType.Long)
    //    ////					context.Emit(OpCodes.Conv_U8);
    //    ////				operand.Emit(context);
    //    ////				context.Emit(OpCodes.Sub_Ovf);
    //    ////			} else {
    //    ////				operand.Emit(context);
    //    ////				context.Emit(OpCodes.Neg);
    //    ////			}

    //    ////			break;

    //    ////		case Operator.LogicalNot:
    //    ////			operand.Emit(context);
    //    ////			context.EmitInt(0);
    //    ////			context.Emit(OpCodes.Ceq);
    //    ////			break;

    //    ////		case Operator.OnesComplement:
    //    ////			operand.Emit(context);
    //    ////			context.Emit(OpCodes.Not);
    //    ////			break;

    //    ////		case Operator.AddressOf:
    //    ////			((IMemoryLocation)operand).AddressOf(context, AddressOp.LoadStore);
    //    ////			break;

    //    ////		default:
    //    ////			throw new Exception("This should not happen: Operator = "
    //    ////						 + Oper.ToString());
    //    ////	}

    //    ////	//
    //    ////	// Same trick as in Binary expression
    //    ////	//
    //    ////	if (enum_conversion != null)
    //    ////		enum_conversion.Emit(context);
    //    ////}

    //    ////public override void EmitBranchable(EmitContext context, Label target, bool on_true) {
    //    ////	if (Oper == Operator.LogicalNot)
    //    ////		operand.EmitBranchable(context, target, !on_true);
    //    ////	else
    //    ////		base.EmitBranchable(context, target, on_true);
    //    ////}

    //    ////public override void EmitSideEffect(EmitContext context) {
    //    ////	operand.EmitSideEffect(context);
    //    ////}


    //    //	// <summary>
    //    //	//   This routine will attempt to simplify the unary expression when the
    //    //	//   argument is a constant.
    //    //	// </summary>
    //    //	Constant TryReduceConstant(ResolveContext context, Constant constant) {
    //    //		var e = constant;

    //    //		while (e is EmptyConstantCast)
    //    //			e = ((EmptyConstantCast)e).child;

    //    //		if (e is SideEffectConstant) {
    //    //			Constant r = TryReduceConstant(context, ((SideEffectConstant)e).value);
    //    //			return r == null ? null : new SideEffectConstant(r, e, r.startLocation);
    //    //		}

    //    //		TypeReference expr_type = e.resovledType;

    //    //		switch (Oper) {
    //    //			case Operator.UnaryPlus:
    //    //				// Unary numeric promotions
    //    //				switch (expr_type.builtinType) {
    //    //					case PredefinedTypeReference.BuitinType.Byte:
    //    //						return new IntConstant(((ByteConstant)e).Value, e.startLocation);
    //    //					case PredefinedTypeReference.BuitinType.SByte:
    //    //						return new IntConstant(((SByteConstant)e).Value, e.startLocation);
    //    //					case PredefinedTypeReference.BuitinType.Short:
    //    //						return new IntConstant(((ShortConstant)e).Value, e.startLocation);
    //    //					case PredefinedTypeReference.BuitinType.UShort:
    //    //						return new IntConstant(((UShortConstant)e).Value, e.startLocation);
    //    //					case PredefinedTypeReference.BuitinType.Char:
    //    //						return new IntConstant(((CharConstant)e).Value, e.startLocation);

    //    //					// Predefined operators
    //    //					case PredefinedTypeReference.BuitinType.Int:
    //    //					case PredefinedTypeReference.BuitinType.UInt:
    //    //					case PredefinedTypeReference.BuitinType.Long:
    //    //					case PredefinedTypeReference.BuitinType.ULong:
    //    //					case PredefinedTypeReference.BuitinType.Float:
    //    //					case PredefinedTypeReference.BuitinType.Double:
    //    //					case PredefinedTypeReference.BuitinType.Decimal:
    //    //						return e;
    //    //				}

    //    //				return null;

    //    //			case Operator.UnaryNegation:
    //    //				// Unary numeric promotions
    //    //				switch (expr_type.builtinType) {
    //    //					case PredefinedTypeReference.BuitinType.Byte:
    //    //						return new IntConstant(-((ByteConstant)e).Value, e.startLocation);
    //    //					case PredefinedTypeReference.BuitinType.SByte:
    //    //						return new IntConstant(-((SByteConstant)e).Value, e.startLocation);
    //    //					case PredefinedTypeReference.BuitinType.Short:
    //    //						return new IntConstant(-((ShortConstant)e).Value, e.startLocation);
    //    //					case PredefinedTypeReference.BuitinType.UShort:
    //    //						return new IntConstant(-((UShortConstant)e).Value, e.startLocation);
    //    //					case PredefinedTypeReference.BuitinType.Char:
    //    //						return new IntConstant(-((CharConstant)e).Value, e.startLocation);

    //    //					// Predefined operators
    //    //					case PredefinedTypeReference.BuitinType.Int:
    //    //						int ivalue = ((IntConstant)e).Value;
    //    //						if (ivalue == int.MinValue) {
    //    //							if (context.ConstantCheckState) {
    //    //								ConstantFold.Error_CompileTimeOverflow(context, startLocation);
    //    //								return null;
    //    //							}
    //    //							return e;
    //    //						}
    //    //						return new IntConstant(-ivalue, e.startLocation);

    //    //					case PredefinedTypeReference.BuitinType.Long:
    //    //						long lvalue = ((LongConstant)e).Value;
    //    //						if (lvalue == long.MinValue) {
    //    //							if (context.ConstantCheckState) {
    //    //								ConstantFold.Error_CompileTimeOverflow(context, startLocation);
    //    //								return null;
    //    //							}
    //    //							return e;
    //    //						}
    //    //						return new LongConstant(-lvalue, e.startLocation);

    //    //					case PredefinedTypeReference.BuitinType.UInt:
    //    //						UIntLiteral uil = constant as UIntLiteral;
    //    //						if (uil != null) {
    //    //							if (uil.Value == int.MaxValue + (uint)1)
    //    //								return new IntLiteral(int.MinValue, e.startLocation);
    //    //							return new LongLiteral(-uil.Value, e.startLocation);
    //    //						}
    //    //						return new LongConstant(-((UIntConstant)e).Value, e.startLocation);


    //    //					case PredefinedTypeReference.BuitinType.ULong:
    //    //						ULongLiteral ull = constant as ULongLiteral;
    //    //						if (ull != null && ull.Value == 9223372036854775808)
    //    //							return new LongLiteral(long.MinValue, e.startLocation);
    //    //						return null;

    //    //					case PredefinedTypeReference.BuitinType.Float:
    //    //						FloatLiteral fl = constant as FloatLiteral;
    //    //						// For better error reporting
    //    //						if (fl != null)
    //    //							return new FloatLiteral(-fl.Value, e.startLocation);

    //    //						return new FloatConstant(-((FloatConstant)e).Value, e.startLocation);

    //    //					case PredefinedTypeReference.BuitinType.Double:
    //    //						DoubleLiteral dl = constant as DoubleLiteral;
    //    //						// For better error reporting
    //    //						if (dl != null)
    //    //							return new DoubleLiteral(-dl.Value, e.startLocation);

    //    //						return new DoubleConstant(-((DoubleConstant)e).Value, e.startLocation);

    //    //					case PredefinedTypeReference.BuitinType.Decimal:
    //    //						return new DecimalConstant(-((DecimalConstant)e).Value, e.startLocation);
    //    //				}

    //    //				return null;

    //    //			case Operator.LogicalNot:
    //    //				if (expr_type.builtinType != PredefinedTypeReference.BuitinType.Bool)
    //    //					return null;

    //    //				bool b = (bool)e.GetValue();
    //    //				return new BoolConstant(!b, e.startLocation);

    //    //			case Operator.OnesComplement:
    //    //				// Unary numeric promotions
    //    //				switch (expr_type.builtinType) {
    //    //					case PredefinedTypeReference.BuitinType.Byte:
    //    //						return new IntConstant(~((ByteConstant)e).Value, e.startLocation);
    //    //					case PredefinedTypeReference.BuitinType.SByte:
    //    //						return new IntConstant(~((SByteConstant)e).Value, e.startLocation);
    //    //					case PredefinedTypeReference.BuitinType.Short:
    //    //						return new IntConstant(~((ShortConstant)e).Value, e.startLocation);
    //    //					case PredefinedTypeReference.BuitinType.UShort:
    //    //						return new IntConstant(~((UShortConstant)e).Value, e.startLocation);
    //    //					case PredefinedTypeReference.BuitinType.Char:
    //    //						return new IntConstant(~((CharConstant)e).Value, e.startLocation);

    //    //					// Predefined operators
    //    //					case PredefinedTypeReference.BuitinType.Int:
    //    //						return new IntConstant(~((IntConstant)e).Value, e.startLocation);
    //    //					case PredefinedTypeReference.BuitinType.UInt:
    //    //						return new UIntConstant(~((UIntConstant)e).Value, e.startLocation);
    //    //					case PredefinedTypeReference.BuitinType.Long:
    //    //						return new LongConstant(~((LongConstant)e).Value, e.startLocation);
    //    //					case PredefinedTypeReference.BuitinType.ULong:
    //    //						return new ULongConstant(~((ULongConstant)e).Value, e.startLocation);
    //    //				}
    //    //				if (e is EnumConstant) {
    //    //					e = TryReduceConstant(context, ((EnumConstant)e).Child);
    //    //					if (e != null)
    //    //						e = new EnumConstant(e, expr_type);
    //    //					return e;
    //    //				}
    //    //				return null;
    //    //		}
    //    //		throw new Exception("Can not constant fold: " + Oper.ToString());
    //    //	}

    //    //	protected virtual Expression ResolveOperator(ResolveContext context, Expression expr) {
    //    //		epartial class = _Exprpartial class.Value;

    //    //		TypeReference expr_type = expr.resovledType;
    //    //		Expression best_expr;

    //    //		TypeReference[] predefined = PredefinedTypes.OperatorsUnary[(int)Oper];

    //    //		//
    //    //		// Primitive types first
    //    //		//
    //    //		if (PredefinedTypeReference.IsPrimitiveType(expr_type)) {
    //    //			best_expr = ResolvePrimitivePredefinedType(context, expr, predefined);
    //    //			if (best_expr == null)
    //    //				return null;

    //    //			resovledType = best_expr.resovledType;
    //    //			operand = best_expr;
    //    //			return this;
    //    //		}

    //    //		//
    //    //		// E operator ~(E x);
    //    //		//
    //    //		if (Oper == Operator.OnesComplement && expr_type.IsEnum)
    //    //			return ResolveEnumOperator(context, expr, predefined);

    //    //		return ResolveUserType(context, expr, predefined);
    //    //	}

    //    //	protected virtual Expression ResolveEnumOperator(ResolveContext context, Expression expr, TypeReference[] predefined) {
    //    //		TypeReference underlying_type = EnumReference.GetUnderlyingType(expr.resovledType);
    //    //		Expression best_expr = ResolvePrimitivePredefinedType(context, EmptyCast.Create(expr, underlying_type), predefined);
    //    //		if (best_expr == null)
    //    //			return null;

    //    //		operand = best_expr;
    //    //		enum_conversion = Convert.ExplicitNumericConversion(context, new EmptyExpression(best_expr.resovledType), underlying_type);
    //    //		resovledType = expr.resovledType;
    //    //		return EmptyCast.Create(this, resovledType);
    //    //	}

    //    //	public override bool ContainsEmitWithAwait() {
    //    //		return operand.ContainsEmitWithAwait();
    //    //	}

    //    //	public override Expression CreateExpressionTree(ResolveContext context) {
    //    //		return CreateExpressionTree(context, null);
    //    //	}

    //    //	Expression CreateExpressionTree(ResolveContext context, Expression user_op) {
    //    //		string method_name;
    //    //		switch (Oper) {
    //    //			case Operator.AddressOf:
    //    //				Error_PointerInsideExpressionTree(context);
    //    //				return null;
    //    //			case Operator.UnaryNegation:
    //    //				if (context.HasSet(ResolveContext.Options.CheckedScope) && user_op == null && !IsFloat(resovledType))
    //    //					method_name = "NegateChecked";
    //    //				else
    //    //					method_name = "Negate";
    //    //				break;
    //    //			case Operator.OnesComplement:
    //    //			case Operator.LogicalNot:
    //    //				method_name = "Not";
    //    //				break;
    //    //			case Operator.UnaryPlus:
    //    //				method_name = "UnaryPlus";
    //    //				break;
    //    //			default:
    //    //				throw new InternalErrorException("Unknown unary operator " + Oper.ToString());
    //    //		}

    //    //		Arguments args = new Arguments(2);
    //    //		args.Add(new Argument(operand.CreateExpressionTree(context)));
    //    //		if (user_op != null)
    //    //			args.Add(new Argument(user_op));

    //    //		return CreateExpressionFactoryCall(context, method_name, args);
    //    //	}

    //    //	public static TypeReference[][] CreatePredefinedOperatorsTable() {
    //    //		var predefined_operators = new TypeReference[(int)Operator.TOP][];

    //    //		//
    //    //		// 7.6.1 Unary plus operator
    //    //		//
    //    //		predefined_operators[(int)Operator.UnaryPlus] = new TypeReference[] {
    //    //				PredefinedTypes.Int, PredefinedTypes.UInt,
    //    //				PredefinedTypes.Long, PredefinedTypes.ULong,
    //    //				PredefinedTypes.Float, PredefinedTypes.Double,
    //    //				PredefinedTypes.Decimal
    //    //			};

    //    //		//
    //    //		// 7.6.2 Unary minus operator
    //    //		//
    //    //		predefined_operators[(int)Operator.UnaryNegation] = new TypeReference[] {
    //    //				PredefinedTypes.Int,  PredefinedTypes.Long,
    //    //				PredefinedTypes.Float, PredefinedTypes.Double,
    //    //				PredefinedTypes.Decimal
    //    //			};

    //    //		//
    //    //		// 7.6.3 Logical negation operator
    //    //		//
    //    //		predefined_operators[(int)Operator.LogicalNot] = new TypeReference[] {
    //    //				PredefinedTypes.Bool
    //    //			};

    //    //		//
    //    //		// 7.6.4 Bitwise complement operator
    //    //		//
    //    //		predefined_operators[(int)Operator.OnesComplement] = new TypeReference[] {
    //    //				PredefinedTypes.Int, PredefinedTypes.UInt,
    //    //				PredefinedTypes.Long, PredefinedTypes.ULong
    //    //			};

    //    //		return predefined_operators;
    //    //	}

    //    //	//
    //    //	// Unary numeric promotions
    //    //	//
    //    //	static Expression DoNumericPromotion(ResolveContext rc, Operator op, Expression expr) {
    //    //		TypeReference expr_type = expr.resovledType;
    //    //		if (op == Operator.UnaryPlus || op == Operator.UnaryNegation || op == Operator.OnesComplement) {
    //    //			switch (expr_type.builtinType) {
    //    //				case PredefinedTypeReference.BuitinType.Byte:
    //    //				case PredefinedTypeReference.BuitinType.SByte:
    //    //				case PredefinedTypeReference.BuitinType.Short:
    //    //				case PredefinedTypeReference.BuitinType.UShort:
    //    //				case PredefinedTypeReference.BuitinType.Char:
    //    //					return Convert.ImplicitNumericConversion(expr, PredefinedTypes.Int);
    //    //			}
    //    //		}

    //    //		if (op == Operator.UnaryNegation && expr_type.builtinType == PredefinedTypeReference.BuitinType.UInt)
    //    //			return Convert.ImplicitNumericConversion(expr, PredefinedTypes.Long);

    //    //		return expr;
    //    //	}

    //    //	//
    //    //	// Converts operator to System.Linq.Expressions.ExpressionType enum name
    //    //	//
    //    //	string GetOperatorExpressionTypeName() {
    //    //		switch (Oper) {
    //    //			case Operator.OnesComplement:
    //    //				return "OnesComplement";
    //    //			case Operator.LogicalNot:
    //    //				return "Not";
    //    //			case Operator.UnaryNegation:
    //    //				return "Negate";
    //    //			case Operator.UnaryPlus:
    //    //				return "UnaryPlus";
    //    //			default:
    //    //				throw new NotImplementedException("Unknown express type operator " + Oper.ToString());
    //    //		}
    //    //	}

    //    //	static bool IsFloat(TypeReference t) {
    //    //		return t.builtinType == PredefinedTypeReference.BuitinType.Double || t.builtinType == PredefinedTypeReference.BuitinType.Float;
    //    //	}

    //    //	//
    //    //	// Returns a stringified representation of the Operator
    //    //	//
    //    //	public static string OperName(Operator oper) {
    //    //		switch (oper) {
    //    //			case Operator.UnaryPlus:
    //    //				return "+";
    //    //			case Operator.UnaryNegation:
    //    //				return "-";
    //    //			case Operator.LogicalNot:
    //    //				return "!";
    //    //			case Operator.OnesComplement:
    //    //				return "~";
    //    //			case Operator.AddressOf:
    //    //				return "&";
    //    //		}

    //    //		throw new NotImplementedException(oper.ToString());
    //    //	}

    //    //	public override SLE.Expression MakeExpression(BuilderContext ctx) {
    //    //		var expr = operand.MakeExpression(ctx);
    //    //		bool is_checked = ctx.HasSet(BuilderContext.Options.CheckedScope);

    //    //		switch (Oper) {
    //    //			case Operator.UnaryNegation:
    //    //				return is_checked ? SLE.Expression.NegateChecked(expr) : SLE.Expression.Negate(expr);
    //    //			case Operator.LogicalNot:
    //    //				return SLE.Expression.Not(expr);
    //    //#if NET_4_0 || MONODROID
    //    //			case Operator.OnesComplement:
    //    //				return SLE.Expression.OnesComplement (expr);
    //    //#endif
    //    //			default:
    //    //				throw new NotImplementedException(Oper.ToString());
    //    //		}
    //    //	}

    //    //	Expression ResolveAddressOf(ResolveContext context) {
    //    //		//if (!context.IsUnsafe)
    //    //		//    UnsafeError(context, startLocation);

    //    //		// 获取操作数。
    //    //		operand = operand.onResolveAsLValue(context, EmptyExpression.UnaryAddress);
    //    //		if (operand == null || operand.epartial class != _Exprpartial class.Variable) {
    //    //			context.Report.Error(211, startLocation, "Cannot take the address of the given expression");
    //    //			return null;
    //    //		}

    //    //		if (!TypeManager.VerifyUnmanaged(context.parentModule, operand.resovledType, startLocation)) {
    //    //			return null;
    //    //		}

    //    //		IVariableReference vr = operand as IVariableReference;
    //    //		bool is_fixed;
    //    //		if (vr != null) {
    //    //			is_fixed = vr.IsFixed;
    //    //			vr.SetHasAddressTaken();

    //    //			if (vr.IsHoisted) {
    //    //				AnonymousMethodExpression.Error_AddressOfCapturedVar(context, vr, startLocation);
    //    //			}
    //    //		} else {
    //    //			IFixedExpression fe = operand as IFixedExpression;
    //    //			is_fixed = fe != null && fe.IsFixed;
    //    //		}

    //    //		if (!is_fixed && !context.HasSet(ResolveContext.Options.FixedInitializerScope)) {
    //    //			context.Report.Error(212, startLocation, "You can only take the address of unfixed expression inside of a fixed statement initializer");
    //    //		}

    //    //		resovledType = PredefinedTypes.getPtrType(operand.resovledType);
    //    //		epartial class = _Exprpartial class.Value;
    //    //		return this;
    //    //	}

    //    //	Expression ResolvePrimitivePredefinedType(ResolveContext rc, Expression expr, TypeReference[] predefined) {
    //    //		expr = DoNumericPromotion(rc, Oper, expr);
    //    //		TypeReference expr_type = expr.resovledType;
    //    //		foreach (TypeReference t in predefined) {
    //    //			if (t == expr_type)
    //    //				return expr;
    //    //		}
    //    //		return null;
    //    //	}

    //    //	//
    //    //	// Perform user-operator overload resolution
    //    //	//
    //    //	protected virtual Expression ResolveUserOperator(ResolveContext context, Expression expr) {
    //    //		Mono.CSharp.Operator.OpType op_type;
    //    //		switch (Oper) {
    //    //			case Operator.LogicalNot:
    //    //				op_type = Mono.CSharp.Operator.OpType.LogicalNot; break;
    //    //			case Operator.OnesComplement:
    //    //				op_type = Mono.CSharp.Operator.OpType.OnesComplement; break;
    //    //			case Operator.UnaryNegation:
    //    //				op_type = Mono.CSharp.Operator.OpType.UnaryNegation; break;
    //    //			case Operator.UnaryPlus:
    //    //				op_type = Mono.CSharp.Operator.OpType.UnaryPlus; break;
    //    //			default:
    //    //				throw new InternalErrorException(Oper.ToString());
    //    //		}

    //    //		var methods = MemberReferenceCollection.GetUserOperator(expr.resovledType, op_type, false);
    //    //		if (methods == null)
    //    //			return null;

    //    //		Arguments args = new Arguments(1);
    //    //		args.Add(new Argument(expr));

    //    //		var res = new OverloadResolver(methods, OverloadResolver.Restrictions.BaseMembersIncluded | OverloadResolver.Restrictions.NoBaseMembers, startLocation);
    //    //		var oper = res.ResolveOperator(context, ref args);

    //    //		if (oper == null)
    //    //			return null;

    //    //		operand = args[0].Expr;
    //    //		return new UserOperatorCall(oper, args, CreateExpressionTree, expr.startLocation);
    //    //	}

    //    //	//
    //    //	// Unary user type overload resolution
    //    //	//
    //    //	Expression ResolveUserType(ResolveContext context, Expression expr, TypeReference[] predefined) {
    //    //		Expression best_expr = ResolveUserOperator(context, expr);
    //    //		if (best_expr != null)
    //    //			return best_expr;

    //    //		foreach (TypeReference t in predefined) {
    //    //			Expression oper_expr = Convert.ImplicitUserConversion(context, expr, t, expr.startLocation);
    //    //			if (oper_expr == null)
    //    //				continue;

    //    //			if (oper_expr == ErrorExpression.Instance)
    //    //				return oper_expr;

    //    //			//
    //    //			// decimal type is predefined but has user-operators
    //    //			//
    //    //			if (oper_expr.resovledType.builtinType == PredefinedTypeReference.BuitinType.Decimal)
    //    //				oper_expr = ResolveUserType(context, oper_expr, predefined);
    //    //			else
    //    //				oper_expr = ResolvePrimitivePredefinedType(context, oper_expr, predefined);

    //    //			if (oper_expr == null)
    //    //				continue;

    //    //			if (best_expr == null) {
    //    //				best_expr = oper_expr;
    //    //				continue;
    //    //			}

    //    //			int result = OverloadResolver.BetterTypeConversion(context, best_expr.resovledType, t);
    //    //			if (result == 0) {
    //    //				if ((oper_expr is UserOperatorCall || oper_expr is UserCast) && (best_expr is UserOperatorCall || best_expr is UserCast)) {
    //    //					context.Report.Error(35, startLocation, "Operator `{0}' is ambiguous on an operand of type `{1}'",
    //    //						OperName(Oper), expr.resovledType.GetSignatureForError());
    //    //				} else {
    //    //					Error_OperatorCannotBeApplied(context, startLocation, OperName(Oper), expr.resovledType);
    //    //				}

    //    //				break;
    //    //			}

    //    //			if (result == 2)
    //    //				best_expr = oper_expr;
    //    //		}

    //    //		if (best_expr == null)
    //    //			return null;

    //    //		//
    //    //		// HACK: Decimal user-operator is included in standard operators
    //    //		//
    //    //		if (best_expr.resovledType.builtinType == PredefinedTypeReference.BuitinType.Decimal)
    //    //			return best_expr;

    //    //		operand = best_expr;
    //    //		resovledType = best_expr.resovledType;
    //    //		return this;
    //    //	}

    //    //	protected override void CloneTo(CloneContext clonectx, Expression t) {
    //    //		UnaryExpression target = (UnaryExpression)t;

    //    //		target.operand = operand.Clone(clonectx);
    //    //	}

    //    //	public override object Accept(StructuralVisitor visitor) {
    //    //		return visitor.Visit(this);
    //    //	}

    //}

    ///// <summary>
    ///// 表示一个 ++ 或 -- 运算表达式。
    ///// </summary>
    //public partial class MutatorExpression : UnaryExpression {




    //    //public override Expression resolveAsValue(ResolveContext context) {
    //    //    operand = operand.resolveAsValue(context);
    //    //    return this;
    //    //}


    //    //#region 生成

    //    //public override void emit(EmitContext context) {
    //    //    switch (@operator) {
    //    //        case TokenType.inc:
    //    //            operand.emit(context);
    //    //            context.emitLoadInt32(1);
    //    //            context.emitAdd();
    //    //            break;
    //    //        case TokenType.dec:
    //    //            operand.emit(context);
    //    //            context.emitLoadInt32(-1);
    //    //            context.emitAdd();
    //    //            break;
    //    //        default:
    //    //            Compiler.notImplement(this);
    //    //            break;
    //    //    }
    //    //}


    //}

    ///// <summary>
    ///// 表示一个二元运算表达式。
    ///// </summary>
    //public partial class BinaryExpression : Expression {




    //    ///// <summary>
    //    ///// 获取当前操作返回类型。
    //    ///// </summary>
    //    //public TypeReference returnType;

    //    ///// <summary>
    //    ///// 获取当前表达式解析后的返回值类型。
    //    ///// </summary>
    //    //public override TypeReference resolvedType {
    //    //    get {
    //    //        return returnType;
    //    //    }
    //    //}

    //    ///// <summary>
    //    ///// 将当前表达式作为右值解析。
    //    ///// </summary>
    //    ///// <param name="context">用于存储所有解析信息的上下文对象。</param>
    //    ///// <returns>返回解析后的新表达式，它的所有子表达式都已经被解析。如果解析出现错误则返回 null 。</returns>
    //    //public override Expression resolveAsValue(ResolveContext context) {

    //    //    if (@operator.isAssignOperator()) {
    //    //        switch (@operator) {
    //    //            case TokenType.assign:
    //    //                return resolveAssign(context);
    //    //            case TokenType.assignTo:
    //    //                return resolveAssignTo(context);
    //    //            case TokenType.assignBind:
    //    //                return resolveAssignBind(context);
    //    //            default:
    //    //                return resolveArithmeticAssign(context);
    //    //        }
    //    //    }

    //    //    switch (@operator) {
    //    //        case TokenType.@is:
    //    //        case TokenType.@as:
    //    //            return resolveIsOrAs(context);
    //    //        case TokenType.eq:
    //    //        case TokenType.ne:
    //    //        case TokenType.lt:
    //    //        case TokenType.lte:
    //    //        case TokenType.gt:
    //    //        case TokenType.gte:
    //    //            return resolveComparion(context);
    //    //        default:
    //    //            return resolveArithmetic(context);
    //    //    }

    //    //}

    //    //private Expression resolveAssign(ResolveContext context) {
    //    //    var leftRef = leftOperand.resolveAsSymbol(context, ReferenceUsage.setValue);
    //    //    var rightVal = rightOperand.resolveAsValue(context);
    //    //    if (leftRef == null || rightVal == null || (rightVal = rightVal.castTo(leftRef.resolvedType, false, rightOperand)) == null) {
    //    //        return null;
    //    //    }

    //    //    return leftRef.setValue(context, rightVal, this);
    //    //}

    //    //private Expression resolveAssignTo(ResolveContext context) {
    //    //    var leftVal = leftOperand.resolveAsValue(context);
    //    //    var rightRef = rightOperand.resolveAsSymbol(context, ReferenceUsage.setValue);
    //    //    if (leftVal == null || rightRef == null || (leftVal = leftVal.castTo(rightRef.resolvedType, false, leftOperand)) == null) {
    //    //        return null;
    //    //    }

    //    //    return rightRef.setValue(context, leftVal, this);
    //    //}

    //    //private Expression resolveAssignBind(ResolveContext context) {
    //    //    Compiler.notImplement(this);
    //    //    return resolveAssign(context);
    //    //}

    //    //private Expression resolveArithmeticAssign(ResolveContext context) {
    //    //    var leftRef = leftOperand.resolveAsSymbol(context, ReferenceUsage.getValue);
    //    //    var leftVal = leftRef != null ? leftRef.getValue(context, leftOperand) : null;
    //    //    var rightVal = rightOperand.resolveAsValue(context);
    //    //    if (leftVal == null || rightVal == null) {
    //    //        return null;
    //    //    }

    //    //    // 计算赋值的值。
    //    //    rightVal = resolveArithmetic(context, leftVal, rightVal);
    //    //    if (rightVal == null || (rightVal = rightVal.castTo(leftRef.resolvedType, false, rightOperand)) == null) {
    //    //        return null;
    //    //    }

    //    //    return leftRef.setValue(context, rightVal, this);
    //    //}

    //    //private Expression resolveIsOrAs(ResolveContext context) {
    //    //    var leftVal = leftOperand.resolveAsValue(context);
    //    //    var rightRef = rightOperand.resolveAsType(context.containerMemberDefinition, MemberUsage.typeDefinition);
    //    //    if (leftVal == null || rightRef == null) {
    //    //        return null;
    //    //    }

    //    //    Compiler.notImplement(this);
    //    //    return this;
    //    //}

    //    //private Expression resolveComparion(ResolveContext context) {
    //    //    var leftRef = leftOperand.resolveAsSymbol(context, ReferenceUsage.getValue);
    //    //    var rightRef = rightOperand.resolveAsSymbol(context, ReferenceUsage.getValue);
    //    //    if (leftRef == null || rightRef == null) {
    //    //        return null;
    //    //    }

    //    //    // todo 
    //    //    if (leftRef == rightRef) {
    //    //        Compiler.warning(1, "对同一个变量进行比较，是否有拼写错误?", this);
    //    //    }

    //    //    var leftVal = leftRef.getValue(context, leftOperand);
    //    //    var rightVal = rightRef.getValue(context, rightOperand);
    //    //    if (leftVal == null || rightVal == null) {
    //    //        return null;
    //    //    }

    //    //    // 处理用户自定义操作符重载。
    //    //    if (leftVal.resolvedType.primitiveType == PrimitiveType.none || rightVal.resolvedType.primitiveType == PrimitiveType.none) {
    //    //        return resolveUserOperator(context, leftVal, rightVal);
    //    //    }

    //    //    returnType = PredefinedTypes.@bool;

    //    //    var leftPrimitiveType = leftVal.resolvedType.primitiveType;
    //    //    var rightPrimitiveType = rightVal.resolvedType.primitiveType;

    //    //    if (leftPrimitiveType == PrimitiveType.@bool || rightPrimitiveType == PrimitiveType.@bool) {

    //    //        // bool 只支持 == 和 !=
    //    //        if (@operator != TokenType.eq && @operator != TokenType.ne) {
    //    //            reportOperatorError();
    //    //            return null;
    //    //        }

    //    //        leftOperand = ResolveHelper.toBool(leftVal);
    //    //        rightOperand = ResolveHelper.toBool(rightVal);
    //    //        return this;

    //    //    }

    //    //    if (leftPrimitiveType == PrimitiveType.@ptr || rightPrimitiveType == PrimitiveType.@ptr) {

    //    //        // 指针只能和指针比较
    //    //        if (leftPrimitiveType != PrimitiveType.@ptr && rightPrimitiveType != PrimitiveType.ptr) {
    //    //            reportOperatorError();
    //    //            return null;
    //    //        }

    //    //        leftOperand = leftVal;
    //    //        rightOperand = rightVal;

    //    //        return this;
    //    //    }

    //    //    promoteType(leftVal, rightVal);

    //    //    // 优化常量
    //    //    if (leftOperand.isConst && rightOperand.isConst) {
    //    //        int val;
    //    //        switch (returnType.primitiveType) {
    //    //            case PrimitiveType.@int:
    //    //                val = ((IntConstant)leftOperand).value.CompareTo(((IntConstant)rightOperand).value);
    //    //                break;

    //    //            case PrimitiveType.@uint:
    //    //                val = ((UIntConstant)leftOperand).value.CompareTo(((UIntConstant)rightOperand).value);
    //    //                break;

    //    //            case PrimitiveType.@long:
    //    //                val = ((LongConstant)leftOperand).value.CompareTo(((LongConstant)rightOperand).value);
    //    //                break;

    //    //            case PrimitiveType.@ulong:
    //    //                val = ((ULongConstant)leftOperand).value.CompareTo(((ULongConstant)rightOperand).value);
    //    //                break;

    //    //            case PrimitiveType.@float:
    //    //                val = ((FloatConstant)leftOperand).value.CompareTo(((FloatConstant)rightOperand).value);
    //    //                break;

    //    //            case PrimitiveType.@double:
    //    //                val = ((DoubleConstant)leftOperand).value.CompareTo(((DoubleConstant)rightOperand).value);
    //    //                break;

    //    //            default:
    //    //                throw new NotSupportedException();
    //    //        }

    //    //        bool retValue;
    //    //        switch (@operator) {
    //    //            case TokenType.eq:
    //    //                retValue = val == 0;
    //    //                break;
    //    //            case TokenType.ne:
    //    //                retValue = val != 0;
    //    //                break;
    //    //            case TokenType.lt:
    //    //                retValue = val < 0;
    //    //                break;
    //    //            case TokenType.lte:
    //    //                retValue = val <= 0;
    //    //                break;
    //    //            case TokenType.gt:
    //    //                retValue = val > 0;
    //    //                break;
    //    //            case TokenType.gte:
    //    //                retValue = val >= 0;
    //    //                break;
    //    //            default:
    //    //                throw new NotSupportedException();
    //    //        }

    //    //        return retValue ? BoolConstant.@true : BoolConstant.@false;
    //    //    }


    //    //    return this;
    //    //}

    //    //private Expression resolveArithmetic(ResolveContext context) {
    //    //    var leftVal = leftOperand.resolveAsValue(context);
    //    //    var rightVal = rightOperand.resolveAsValue(context);
    //    //    if (leftVal == null || rightVal == null) {
    //    //        return null;
    //    //    }

    //    //    switch (@operator) {
    //    //        case TokenType.add:
    //    //        case TokenType.assignAdd:
    //    //        case TokenType.sub:
    //    //        case TokenType.assignSub:
    //    //        case TokenType.mul:
    //    //        case TokenType.assignMul:
    //    //        case TokenType.div:
    //    //        case TokenType.assignDiv:
    //    //        case TokenType.mod:
    //    //        case TokenType.assignMod:
    //    //        case TokenType.pow:
    //    //            return resolveArithmetic(context, leftVal, rightVal);

    //    //        case TokenType.logicalAnd:
    //    //        case TokenType.logicalOr:
    //    //            return resolveLogical(context, leftVal, rightVal);

    //    //        case TokenType.bitOr:
    //    //        case TokenType.bitAnd:
    //    //        case TokenType.bitXor:
    //    //            return resolveBitwise(context, leftVal, rightVal);

    //    //        case TokenType.bitShl:
    //    //        case TokenType.bitShr:
    //    //            return resolveShift(context, leftVal, rightVal);

    //    //        case TokenType.varAnd:
    //    //        case TokenType.assignVarAnd:
    //    //        case TokenType.varOr:
    //    //        case TokenType.assignVarOr:
    //    //            return resolveVariable(context, leftVal, rightVal);

    //    //        default:
    //    //            throw new NotSupportedException();
    //    //    }

    //    //}

    //    ///// <summary>
    //    ///// 解析用户自定义的操作符。
    //    ///// </summary>
    //    ///// <param name="context"></param>
    //    ///// <param name="leftVal"></param>
    //    ///// <param name="rightVal"></param>
    //    ///// <returns></returns>
    //    //private Expression resolveUserOperator(ResolveContext context, Expression leftVal, Expression rightVal) {
    //    //    return this;
    //    //}

    //    //private Expression resolveArithmetic(ResolveContext context, Expression leftVal, Expression rightVal) {

    //    //    var leftPrimitiveType = leftVal.resolvedType.primitiveType;
    //    //    var rightPrimitiveType = rightVal.resolvedType.primitiveType;

    //    //    // 处理用户自定义操作符重载。
    //    //    if (leftPrimitiveType == PrimitiveType.none || rightPrimitiveType == PrimitiveType.none) {
    //    //        return resolveUserOperator(context, leftVal, rightVal);
    //    //    }

    //    //    // bool 不参与计算。
    //    //    if (leftPrimitiveType == PrimitiveType.@bool || rightPrimitiveType == PrimitiveType.@bool) {
    //    //        reportOperatorError();
    //    //        return null;
    //    //    }

    //    //    // 指针只能加减，且不能有小数。
    //    //    if (leftPrimitiveType == PrimitiveType.@ptr || rightPrimitiveType == PrimitiveType.@ptr) {

    //    //        switch (@operator) {
    //    //            case TokenType.add:
    //    //            case TokenType.assignAdd:
    //    //            case TokenType.sub:
    //    //            case TokenType.assignSub:
    //    //                if (leftPrimitiveType == PrimitiveType.ptr) {
    //    //                    if (isNotInteger(rightPrimitiveType)) {
    //    //                        goto default;
    //    //                    }
    //    //                    leftOperand = leftVal;
    //    //                    rightOperand = ResolveHelper.toULong(rightVal);
    //    //                    returnType = leftVal.resolvedType;
    //    //                } else {
    //    //                    if (isNotInteger(leftPrimitiveType)) {
    //    //                        goto default;
    //    //                    }
    //    //                    leftOperand = ResolveHelper.toULong(leftVal);
    //    //                    rightOperand = rightVal;
    //    //                    returnType = rightVal.resolvedType;
    //    //                }
    //    //                return this;
    //    //            default:
    //    //                reportOperatorError();
    //    //                return null;
    //    //        }

    //    //    }

    //    //    promoteType(leftVal, rightVal);
    //    //    returnType = leftOperand.resolvedType;

    //    //    // 优化常量
    //    //    if (leftOperand.isConst && rightOperand.isConst) {
    //    //        switch (returnType.primitiveType) {

    //    //            case PrimitiveType.@int: {
    //    //                    IntConstant ret = new IntConstant();
    //    //                    switch (@operator) {
    //    //                        case TokenType.add:
    //    //                        case TokenType.assignAdd:
    //    //                            ret.value = ((IntConstant)leftOperand).value + ((IntConstant)rightOperand).value;
    //    //                            break;
    //    //                        case TokenType.sub:
    //    //                        case TokenType.assignSub:
    //    //                            ret.value = ((IntConstant)leftOperand).value - ((IntConstant)rightOperand).value;
    //    //                            break;
    //    //                        case TokenType.mul:
    //    //                        case TokenType.assignMul:
    //    //                            ret.value = ((IntConstant)leftOperand).value * ((IntConstant)rightOperand).value;
    //    //                            break;
    //    //                        case TokenType.div:
    //    //                        case TokenType.assignDiv:
    //    //                            ret.value = ((IntConstant)leftOperand).value / ((IntConstant)rightOperand).value;
    //    //                            break;
    //    //                        case TokenType.mod:
    //    //                        case TokenType.assignMod:
    //    //                            ret.value = ((IntConstant)leftOperand).value % ((IntConstant)rightOperand).value;
    //    //                            break;
    //    //                        case TokenType.pow:
    //    //                            ret.value = (int)Math.Pow(((IntConstant)leftOperand).value, ((IntConstant)rightOperand).value);
    //    //                            break;
    //    //                    }
    //    //                    return ret;
    //    //                }

    //    //            case PrimitiveType.@uint: {
    //    //                    UIntConstant ret = new UIntConstant();
    //    //                    switch (@operator) {
    //    //                        case TokenType.add:
    //    //                        case TokenType.assignAdd:
    //    //                            ret.value = ((UIntConstant)leftOperand).value + ((UIntConstant)rightOperand).value;
    //    //                            break;
    //    //                        case TokenType.sub:
    //    //                        case TokenType.assignSub:
    //    //                            ret.value = ((UIntConstant)leftOperand).value - ((UIntConstant)rightOperand).value;
    //    //                            break;
    //    //                        case TokenType.mul:
    //    //                        case TokenType.assignMul:
    //    //                            ret.value = ((UIntConstant)leftOperand).value * ((UIntConstant)rightOperand).value;
    //    //                            break;
    //    //                        case TokenType.div:
    //    //                        case TokenType.assignDiv:
    //    //                            ret.value = ((UIntConstant)leftOperand).value / ((UIntConstant)rightOperand).value;
    //    //                            break;
    //    //                        case TokenType.mod:
    //    //                        case TokenType.assignMod:
    //    //                            ret.value = ((UIntConstant)leftOperand).value % ((UIntConstant)rightOperand).value;
    //    //                            break;
    //    //                        case TokenType.pow:
    //    //                            ret.value = (uint)Math.Pow(((UIntConstant)leftOperand).value, ((UIntConstant)rightOperand).value);
    //    //                            break;
    //    //                    }
    //    //                    return ret;
    //    //                }

    //    //            case PrimitiveType.@long: {
    //    //                    LongConstant ret = new LongConstant();
    //    //                    switch (@operator) {
    //    //                        case TokenType.add:
    //    //                        case TokenType.assignAdd:
    //    //                            ret.value = ((LongConstant)leftOperand).value + ((LongConstant)rightOperand).value;
    //    //                            break;
    //    //                        case TokenType.sub:
    //    //                        case TokenType.assignSub:
    //    //                            ret.value = ((LongConstant)leftOperand).value - ((LongConstant)rightOperand).value;
    //    //                            break;
    //    //                        case TokenType.mul:
    //    //                        case TokenType.assignMul:
    //    //                            ret.value = ((LongConstant)leftOperand).value * ((LongConstant)rightOperand).value;
    //    //                            break;
    //    //                        case TokenType.div:
    //    //                        case TokenType.assignDiv:
    //    //                            ret.value = ((LongConstant)leftOperand).value / ((LongConstant)rightOperand).value;
    //    //                            break;
    //    //                        case TokenType.mod:
    //    //                        case TokenType.assignMod:
    //    //                            ret.value = ((LongConstant)leftOperand).value % ((LongConstant)rightOperand).value;
    //    //                            break;
    //    //                        case TokenType.pow:
    //    //                            ret.value = (long)Math.Pow(((LongConstant)leftOperand).value, ((LongConstant)rightOperand).value);
    //    //                            break;
    //    //                    }
    //    //                    return ret;
    //    //                }

    //    //            case PrimitiveType.@ulong: {
    //    //                    ULongConstant ret = new ULongConstant();
    //    //                    switch (@operator) {
    //    //                        case TokenType.add:
    //    //                        case TokenType.assignAdd:
    //    //                            ret.value = ((ULongConstant)leftOperand).value + ((ULongConstant)rightOperand).value;
    //    //                            break;
    //    //                        case TokenType.sub:
    //    //                        case TokenType.assignSub:
    //    //                            ret.value = ((ULongConstant)leftOperand).value - ((ULongConstant)rightOperand).value;
    //    //                            break;
    //    //                        case TokenType.mul:
    //    //                        case TokenType.assignMul:
    //    //                            ret.value = ((ULongConstant)leftOperand).value * ((ULongConstant)rightOperand).value;
    //    //                            break;
    //    //                        case TokenType.div:
    //    //                        case TokenType.assignDiv:
    //    //                            ret.value = ((ULongConstant)leftOperand).value / ((ULongConstant)rightOperand).value;
    //    //                            break;
    //    //                        case TokenType.mod:
    //    //                        case TokenType.assignMod:
    //    //                            ret.value = ((ULongConstant)leftOperand).value % ((ULongConstant)rightOperand).value;
    //    //                            break;
    //    //                        case TokenType.pow:
    //    //                            ret.value = (ulong)Math.Pow(((ULongConstant)leftOperand).value, ((ULongConstant)rightOperand).value);
    //    //                            break;
    //    //                    }
    //    //                    return ret;
    //    //                }

    //    //            case PrimitiveType.@float: {
    //    //                    FloatConstant ret = new FloatConstant();
    //    //                    switch (@operator) {
    //    //                        case TokenType.add:
    //    //                        case TokenType.assignAdd:
    //    //                            ret.value = ((FloatConstant)leftOperand).value + ((FloatConstant)rightOperand).value;
    //    //                            break;
    //    //                        case TokenType.sub:
    //    //                        case TokenType.assignSub:
    //    //                            ret.value = ((FloatConstant)leftOperand).value - ((FloatConstant)rightOperand).value;
    //    //                            break;
    //    //                        case TokenType.mul:
    //    //                        case TokenType.assignMul:
    //    //                            ret.value = ((FloatConstant)leftOperand).value * ((FloatConstant)rightOperand).value;
    //    //                            break;
    //    //                        case TokenType.div:
    //    //                        case TokenType.assignDiv:
    //    //                            ret.value = ((FloatConstant)leftOperand).value / ((FloatConstant)rightOperand).value;
    //    //                            break;
    //    //                        case TokenType.mod:
    //    //                        case TokenType.assignMod:
    //    //                            ret.value = ((FloatConstant)leftOperand).value % ((FloatConstant)rightOperand).value;
    //    //                            break;
    //    //                        case TokenType.pow:
    //    //                            ret.value = (float)Math.Pow(((FloatConstant)leftOperand).value, ((FloatConstant)rightOperand).value);
    //    //                            break;
    //    //                    }
    //    //                    return ret;
    //    //                }

    //    //            case PrimitiveType.@double: {
    //    //                    DoubleConstant ret = new DoubleConstant();
    //    //                    switch (@operator) {
    //    //                        case TokenType.add:
    //    //                        case TokenType.assignAdd:
    //    //                            ret.value = ((DoubleConstant)leftOperand).value + ((DoubleConstant)rightOperand).value;
    //    //                            break;
    //    //                        case TokenType.sub:
    //    //                        case TokenType.assignSub:
    //    //                            ret.value = ((DoubleConstant)leftOperand).value - ((DoubleConstant)rightOperand).value;
    //    //                            break;
    //    //                        case TokenType.mul:
    //    //                        case TokenType.assignMul:
    //    //                            ret.value = ((DoubleConstant)leftOperand).value * ((DoubleConstant)rightOperand).value;
    //    //                            break;
    //    //                        case TokenType.div:
    //    //                        case TokenType.assignDiv:
    //    //                            ret.value = ((DoubleConstant)leftOperand).value / ((DoubleConstant)rightOperand).value;
    //    //                            break;
    //    //                        case TokenType.mod:
    //    //                        case TokenType.assignMod:
    //    //                            ret.value = ((DoubleConstant)leftOperand).value % ((DoubleConstant)rightOperand).value;
    //    //                            break;
    //    //                        case TokenType.pow:
    //    //                            ret.value = (double)Math.Pow(((DoubleConstant)leftOperand).value, ((DoubleConstant)rightOperand).value);
    //    //                            break;
    //    //                    }
    //    //                    return ret;
    //    //                }

    //    //            default:
    //    //                throw new NotSupportedException();
    //    //        }
    //    //    }

    //    //    return this;
    //    //}

    //    //private Expression resolveLogical(ResolveContext context, Expression leftVal, Expression rightVal) {

    //    //    // 优化常量。
    //    //    if (leftVal.isConst && rightVal.isConst) {
    //    //        leftVal = ResolveHelper.toBool(leftVal);
    //    //        rightVal = ResolveHelper.toBool(rightVal);
    //    //        bool l = leftVal == BoolConstant.@true;
    //    //        bool r = rightVal == BoolConstant.@true;
    //    //        if (l == (@operator == TokenType.logicalOr)) {
    //    //            rightOperand.reportUnreachableCodeWarning();
    //    //        }
    //    //        return (@operator == TokenType.logicalOr ? (l || r) : (l && r)) ? BoolConstant.@true : BoolConstant.@false;
    //    //    }

    //    //    leftOperand = ResolveHelper.toBool(leftVal);
    //    //    rightOperand = ResolveHelper.toBool(rightVal);
    //    //    returnType = PredefinedTypes.@bool;
    //    //    return this;
    //    //}

    //    //private Expression resolveBitwise(ResolveContext context, Expression leftVal, Expression rightVal) {

    //    //    if (isNotInteger(leftVal.resolvedType.primitiveType) || isNotInteger(rightVal.resolvedType.primitiveType)) {
    //    //        reportOperatorError();
    //    //        return null;
    //    //    }

    //    //    // 处理用户自定义操作符重载。
    //    //    if (leftVal.resolvedType.primitiveType == PrimitiveType.none || rightVal.resolvedType.primitiveType == PrimitiveType.none) {
    //    //        return resolveUserOperator(context, leftVal, rightVal);
    //    //    }

    //    //    promoteType(leftVal, rightVal);
    //    //    returnType = leftOperand.resolvedType;

    //    //    // 优化常量
    //    //    if (leftOperand.isConst && rightOperand.isConst) {
    //    //        switch (returnType.primitiveType) {

    //    //            case PrimitiveType.@int: {
    //    //                    IntConstant ret = new IntConstant();
    //    //                    switch (@operator) {
    //    //                        case TokenType.bitOr:
    //    //                            ret.value = ((IntConstant)leftOperand).value | ((IntConstant)rightOperand).value;
    //    //                            break;
    //    //                        case TokenType.bitAnd:
    //    //                            ret.value = ((IntConstant)leftOperand).value & ((IntConstant)rightOperand).value;
    //    //                            break;
    //    //                        case TokenType.bitXor:
    //    //                            ret.value = ((IntConstant)leftOperand).value ^ ((IntConstant)rightOperand).value;
    //    //                            break;
    //    //                        case TokenType.bitShl:
    //    //                            ret.value = ((IntConstant)leftOperand).value << ((IntConstant)rightOperand).value;
    //    //                            break;
    //    //                        case TokenType.bitShr:
    //    //                            ret.value = ((IntConstant)leftOperand).value >> ((IntConstant)rightOperand).value;
    //    //                            break;
    //    //                    }
    //    //                    return ret;
    //    //                }

    //    //            case PrimitiveType.@uint: {
    //    //                    UIntConstant ret = new UIntConstant();
    //    //                    switch (@operator) {
    //    //                        case TokenType.bitOr:
    //    //                            ret.value = ((UIntConstant)leftOperand).value | ((UIntConstant)rightOperand).value;
    //    //                            break;
    //    //                        case TokenType.bitAnd:
    //    //                            ret.value = ((UIntConstant)leftOperand).value & ((UIntConstant)rightOperand).value;
    //    //                            break;
    //    //                        case TokenType.bitXor:
    //    //                            ret.value = ((UIntConstant)leftOperand).value ^ ((UIntConstant)rightOperand).value;
    //    //                            break;
    //    //                    }
    //    //                    return ret;
    //    //                }

    //    //            case PrimitiveType.@long: {
    //    //                    LongConstant ret = new LongConstant();
    //    //                    switch (@operator) {
    //    //                        case TokenType.bitOr:
    //    //                            ret.value = ((LongConstant)leftOperand).value | ((LongConstant)rightOperand).value;
    //    //                            break;
    //    //                        case TokenType.bitAnd:
    //    //                            ret.value = ((LongConstant)leftOperand).value & ((LongConstant)rightOperand).value;
    //    //                            break;
    //    //                        case TokenType.bitXor:
    //    //                            ret.value = ((LongConstant)leftOperand).value ^ ((LongConstant)rightOperand).value;
    //    //                            break;
    //    //                    }
    //    //                    return ret;
    //    //                }

    //    //            case PrimitiveType.@ulong: {
    //    //                    ULongConstant ret = new ULongConstant();
    //    //                    switch (@operator) {
    //    //                        case TokenType.bitOr:
    //    //                            ret.value = ((ULongConstant)leftOperand).value | ((ULongConstant)rightOperand).value;
    //    //                            break;
    //    //                        case TokenType.bitAnd:
    //    //                            ret.value = ((ULongConstant)leftOperand).value & ((ULongConstant)rightOperand).value;
    //    //                            break;
    //    //                        case TokenType.bitXor:
    //    //                            ret.value = ((ULongConstant)leftOperand).value ^ ((ULongConstant)rightOperand).value;
    //    //                            break;
    //    //                    }
    //    //                    return ret;
    //    //                }

    //    //        }
    //    //    }

    //    //    // 优化常量。
    //    //    return this;
    //    //}

    //    //private static bool isNotInteger(PrimitiveType type) {
    //    //    switch (type) {
    //    //        case PrimitiveType.@bool:
    //    //        case PrimitiveType.@double:
    //    //        case PrimitiveType.@float:
    //    //        case PrimitiveType.ptr:
    //    //            return true;
    //    //        default:
    //    //            return false;
    //    //    }
    //    //}

    //    //private Expression resolveShift(ResolveContext context, Expression leftVal, Expression rightVal) {
    //    //    switch (rightVal.resolvedType.primitiveType) {
    //    //        case PrimitiveType.@int:
    //    //            break;
    //    //        case PrimitiveType.@sbyte:
    //    //        case PrimitiveType.@byte:
    //    //        case PrimitiveType.@short:
    //    //        case PrimitiveType.@ushort:
    //    //            rightVal = ResolveHelper.toInt(rightVal);
    //    //            break;
    //    //        default:
    //    //            reportOperatorError();
    //    //            return null;
    //    //    }

    //    //    return resolveBitwise(context, leftVal, rightVal);
    //    //}

    //    //private Expression resolveVariable(ResolveContext context, Expression leftVal, Expression rightVal) {
    //    //    Compiler.notImplement(this);
    //    //    return null;
    //    //}

    //    //private void promoteType(Expression leftVal, Expression rightVal) {
    //    //    switch (leftVal.resolvedType.primitiveType) {
    //    //        case PrimitiveType.@int:
    //    //            switch (rightVal.resolvedType.primitiveType) {
    //    //                case PrimitiveType.@int:
    //    //                    break;
    //    //                case PrimitiveType.@double:
    //    //                    leftVal = ResolveHelper.toDouble(leftVal);
    //    //                    break;
    //    //                case PrimitiveType.@float:
    //    //                    leftVal = ResolveHelper.toFloat(leftVal);
    //    //                    break;
    //    //                case PrimitiveType.@ulong:
    //    //                    leftVal = ResolveHelper.toULong(leftVal);
    //    //                    break;
    //    //                case PrimitiveType.@long:
    //    //                    leftVal = ResolveHelper.toLong(leftVal);
    //    //                    break;
    //    //                case PrimitiveType.@uint:
    //    //                    leftVal = ResolveHelper.toUInt(leftVal);
    //    //                    break;
    //    //                case PrimitiveType.@char:
    //    //                case PrimitiveType.@byte:
    //    //                case PrimitiveType.@short:
    //    //                case PrimitiveType.@ushort:
    //    //                case PrimitiveType.@sbyte:
    //    //                    rightVal = ResolveHelper.toInt(rightVal);
    //    //                    break;
    //    //                default:
    //    //                    throw new NotSupportedException();
    //    //            }
    //    //            break;
    //    //        case PrimitiveType.@double:
    //    //            rightVal = ResolveHelper.toDouble(rightVal);
    //    //            break;
    //    //        case PrimitiveType.@float:
    //    //            switch (rightVal.resolvedType.primitiveType) {
    //    //                case PrimitiveType.@double:
    //    //                    leftVal = ResolveHelper.toDouble(leftVal);
    //    //                    break;
    //    //                default:
    //    //                    rightVal = ResolveHelper.toFloat(rightVal);
    //    //                    break;
    //    //            }
    //    //            break;
    //    //        case PrimitiveType.@ulong:
    //    //            switch (rightVal.resolvedType.primitiveType) {
    //    //                case PrimitiveType.@double:
    //    //                    leftVal = ResolveHelper.toDouble(leftVal);
    //    //                    break;
    //    //                case PrimitiveType.@float:
    //    //                    leftVal = ResolveHelper.toFloat(leftVal);
    //    //                    break;
    //    //                default:
    //    //                    rightVal = ResolveHelper.toULong(rightVal);
    //    //                    break;
    //    //            }
    //    //            break;
    //    //        case PrimitiveType.@long:
    //    //            switch (rightVal.resolvedType.primitiveType) {
    //    //                case PrimitiveType.@double:
    //    //                    leftVal = ResolveHelper.toDouble(leftVal);
    //    //                    break;
    //    //                case PrimitiveType.@float:
    //    //                    leftVal = ResolveHelper.toFloat(leftVal);
    //    //                    break;
    //    //                case PrimitiveType.@ulong:
    //    //                    leftVal = ResolveHelper.toULong(leftVal);
    //    //                    break;
    //    //                default:
    //    //                    rightVal = ResolveHelper.toLong(rightVal);
    //    //                    break;
    //    //            }
    //    //            break;
    //    //        case PrimitiveType.@uint:
    //    //            switch (rightVal.resolvedType.primitiveType) {
    //    //                case PrimitiveType.@double:
    //    //                    leftVal = ResolveHelper.toDouble(leftVal);
    //    //                    break;
    //    //                case PrimitiveType.@float:
    //    //                    leftVal = ResolveHelper.toFloat(leftVal);
    //    //                    break;
    //    //                case PrimitiveType.@ulong:
    //    //                    leftVal = ResolveHelper.toULong(leftVal);
    //    //                    break;
    //    //                case PrimitiveType.@long:
    //    //                    leftVal = ResolveHelper.toLong(leftVal);
    //    //                    break;
    //    //                default:
    //    //                    rightVal = ResolveHelper.toUInt(rightVal);
    //    //                    break;
    //    //            }
    //    //            break;
    //    //        case PrimitiveType.@char:
    //    //        case PrimitiveType.@byte:
    //    //        case PrimitiveType.@short:
    //    //        case PrimitiveType.@ushort:
    //    //        case PrimitiveType.@sbyte:
    //    //            leftVal = ResolveHelper.toInt(leftVal);
    //    //            goto case PrimitiveType.@int;
    //    //        default:
    //    //            throw new NotSupportedException();
    //    //    }

    //    //    leftOperand = leftVal;
    //    //    rightOperand = rightVal;
    //    //}

    //    //private void reportOperatorError() {
    //    //    Compiler.error(1, String.Format("“{0}”运算符无法应用于“{1}”和“{2}”", @operator.getName(), leftOperand.resolvedType.fullName, rightOperand.resolvedType.fullName), this);
    //    //}


    //    //#region 生成

    //    ///// <summary>
    //    ///// 生成当前节点的代码。
    //    ///// </summary>
    //    ///// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //    //public override void emit(EmitContext context) {
    //    //    leftOperand.emit(context);
    //    //    rightOperand.emit(context);
    //    //    switch (@operator) {
    //    //        case TokenType.add:
    //    //            if (context.checkOverflow) {
    //    //                context.emitAddWithCheck(rightOperand.resolvedType);
    //    //            } else {
    //    //                context.emitAdd();
    //    //            }
    //    //            break;
    //    //        case TokenType.sub:
    //    //            if (context.checkOverflow) {
    //    //                context.emitSubtractOverflow();
    //    //            } else {
    //    //                context.emitSubtract();
    //    //            }
    //    //            break;
    //    //        case TokenType.gt:
    //    //            context.emitCompareGreaterThan();
    //    //            break;
    //    //        case TokenType.lt:
    //    //            context.emitCompareLessThan();
    //    //            break;
    //    //        case TokenType.gte:
    //    //            context.emitCompareLessThan();
    //    //            context.emitLoadInt32(0);
    //    //            context.emitCompareEqual();
    //    //            break;
    //    //        case TokenType.lte:
    //    //            context.emitCompareGreaterThan();
    //    //            context.emitLoadInt32(0);
    //    //            context.emitCompareEqual();
    //    //            break;
    //    //        case TokenType.eq:
    //    //            context.emitCompareEqual();
    //    //            break;
    //    //        case TokenType.ne:
    //    //            context.emitCompareEqual();
    //    //            context.emitLoadInt32(0);
    //    //            context.emitCompareEqual();
    //    //            break;
    //    //        default:
    //    //            Compiler.notImplement(this);
    //    //            break;
    //    //    }
    //    //}

    //    /////// <remarks>
    //    ///////   EmitBranchable is called from Statement.EmitBoolExpression in the
    //    ///////   context of a conditional bool expression.  This function will return
    //    ///////   false if it is was possible to use EmitBranchable, or true if it was.
    //    ///////
    //    ///////   The expression's code is generated, and we will generate a branch to `target'
    //    ///////   if the resulting expression value is equal to isTrue
    //    /////// </remarks>
    //    ////public override void EmitBranchable(EmitContext context, Label target, bool on_true) {
    //    ////	if (context.HasSet(BuilderContext.Options.AsyncBody) && rightOperand.ContainsEmitWithAwait()) {
    //    ////		leftOperand = leftOperand.EmitToField(context);

    //    ////		if ((oper & Operator.LogicalMask) == 0) {
    //    ////			rightOperand = rightOperand.EmitToField(context);
    //    ////		}
    //    ////	}

    //    ////	//
    //    ////	// This is more complicated than it looks, but its just to avoid
    //    ////	// duplicated tests: basically, we allow ==, !=, >, <, >= and <=
    //    ////	// but on top of that we want for == and != to use a special path
    //    ////	// if we are comparing against null
    //    ////	//
    //    ////	if ((oper & Operator.EqualityMask) != 0 && (leftOperand is Constant || rightOperand is Constant)) {
    //    ////		bool my_on_true = oper == Operator.Inequality ? on_true : !on_true;

    //    ////		//
    //    ////		// put the constant on the rhs, for simplicity
    //    ////		//
    //    ////		if (leftOperand is Constant) {
    //    ////			Expression swap = rightOperand;
    //    ////			rightOperand = leftOperand;
    //    ////			leftOperand = swap;
    //    ////		}

    //    ////		//
    //    ////		// brtrue/brfalse works with native int only
    //    ////		//
    //    ////		if (((Constant)rightOperand).IsZeroInteger && rightOperand.resovledType.builtinType != PredefinedTypeReference.BuitinType.Long && rightOperand.resovledType.builtinType != PredefinedTypeReference.BuitinType.ULong) {
    //    ////			leftOperand.EmitBranchable(context, target, my_on_true);
    //    ////			return;
    //    ////		}
    //    ////		if (rightOperand.resovledType.builtinType == PredefinedTypeReference.BuitinType.Bool) {
    //    ////			// rightOperand is a boolean, and it's not 'false' => it is 'true'
    //    ////			leftOperand.EmitBranchable(context, target, !my_on_true);
    //    ////			return;
    //    ////		}

    //    ////	} else if (oper == Operator.LogicalAnd) {

    //    ////		if (on_true) {
    //    ////			Label tests_end = context.DefineLabel();

    //    ////			leftOperand.EmitBranchable(context, tests_end, false);
    //    ////			rightOperand.EmitBranchable(context, target, true);
    //    ////			context.MarkLabel(tests_end);
    //    ////		} else {
    //    ////			//
    //    ////			// This optimizes code like this 
    //    ////			// if (true && i > 4)
    //    ////			//
    //    ////			if (!(leftOperand is Constant))
    //    ////				leftOperand.EmitBranchable(context, target, false);

    //    ////			if (!(rightOperand is Constant))
    //    ////				rightOperand.EmitBranchable(context, target, false);
    //    ////		}

    //    ////		return;

    //    ////	} else if (oper == Operator.LogicalOr) {
    //    ////		if (on_true) {
    //    ////			leftOperand.EmitBranchable(context, target, true);
    //    ////			rightOperand.EmitBranchable(context, target, true);

    //    ////		} else {
    //    ////			Label tests_end = context.DefineLabel();
    //    ////			leftOperand.EmitBranchable(context, tests_end, true);
    //    ////			rightOperand.EmitBranchable(context, target, false);
    //    ////			context.MarkLabel(tests_end);
    //    ////		}

    //    ////		return;

    //    ////	} else if ((oper & Operator.ComparisonMask) == 0) {
    //    ////		base.EmitBranchable(context, target, on_true);
    //    ////		return;
    //    ////	}

    //    ////	leftOperand.Emit(context);
    //    ////	rightOperand.Emit(context);

    //    ////	TypeReference t = leftOperand.resovledType;
    //    ////	bool is_float = IsFloat(t);
    //    ////	bool is_unsigned = is_float || IsUnsigned(t);

    //    ////	switch (oper) {
    //    ////		case Operator.Equality:
    //    ////			if (on_true)
    //    ////				context.Emit(OpCodes.Beq, target);
    //    ////			else
    //    ////				context.Emit(OpCodes.Bne_Un, target);
    //    ////			break;

    //    ////		case Operator.Inequality:
    //    ////			if (on_true)
    //    ////				context.Emit(OpCodes.Bne_Un, target);
    //    ////			else
    //    ////				context.Emit(OpCodes.Beq, target);
    //    ////			break;

    //    ////		case Operator.LessThan:
    //    ////			if (on_true)
    //    ////				if (is_unsigned && !is_float)
    //    ////					context.Emit(OpCodes.Blt_Un, target);
    //    ////				else
    //    ////					context.Emit(OpCodes.Blt, target);
    //    ////			else
    //    ////				if (is_unsigned)
    //    ////					context.Emit(OpCodes.Bge_Un, target);
    //    ////				else
    //    ////					context.Emit(OpCodes.Bge, target);
    //    ////			break;

    //    ////		case Operator.GreaterThan:
    //    ////			if (on_true)
    //    ////				if (is_unsigned && !is_float)
    //    ////					context.Emit(OpCodes.Bgt_Un, target);
    //    ////				else
    //    ////					context.Emit(OpCodes.Bgt, target);
    //    ////			else
    //    ////				if (is_unsigned)
    //    ////					context.Emit(OpCodes.Ble_Un, target);
    //    ////				else
    //    ////					context.Emit(OpCodes.Ble, target);
    //    ////			break;

    //    ////		case Operator.LessThanOrEqual:
    //    ////			if (on_true)
    //    ////				if (is_unsigned && !is_float)
    //    ////					context.Emit(OpCodes.Ble_Un, target);
    //    ////				else
    //    ////					context.Emit(OpCodes.Ble, target);
    //    ////			else
    //    ////				if (is_unsigned)
    //    ////					context.Emit(OpCodes.Bgt_Un, target);
    //    ////				else
    //    ////					context.Emit(OpCodes.Bgt, target);
    //    ////			break;


    //    ////		case Operator.GreaterThanOrEqual:
    //    ////			if (on_true)
    //    ////				if (is_unsigned && !is_float)
    //    ////					context.Emit(OpCodes.Bge_Un, target);
    //    ////				else
    //    ////					context.Emit(OpCodes.Bge, target);
    //    ////			else
    //    ////				if (is_unsigned)
    //    ////					context.Emit(OpCodes.Blt_Un, target);
    //    ////				else
    //    ////					context.Emit(OpCodes.Blt, target);
    //    ////			break;
    //    ////		default:
    //    ////			throw new InternalErrorException(oper.ToString());
    //    ////	}
    //    ////}

    //    ////public override void Emit(EmitContext context) {
    //    ////	if (context.HasSet(BuilderContext.Options.AsyncBody) && rightOperand.ContainsEmitWithAwait()) {
    //    ////		leftOperand = leftOperand.EmitToField(context);

    //    ////		if ((oper & Operator.LogicalMask) == 0) {
    //    ////			rightOperand = rightOperand.EmitToField(context);
    //    ////		}
    //    ////	}

    //    ////	//
    //    ////	// Handle short-circuit operators differently
    //    ////	// than the rest
    //    ////	//
    //    ////	if ((oper & Operator.LogicalMask) != 0) {
    //    ////		Label load_result = context.DefineLabel();
    //    ////		Label end = context.DefineLabel();

    //    ////		bool is_or = oper == Operator.LogicalOr;
    //    ////		leftOperand.EmitBranchable(context, load_result, is_or);
    //    ////		rightOperand.Emit(context);
    //    ////		context.Emit(OpCodes.Br_S, end);

    //    ////		context.MarkLabel(load_result);
    //    ////		context.EmitInt(is_or ? 1 : 0);
    //    ////		context.MarkLabel(end);
    //    ////		return;
    //    ////	}

    //    ////	//
    //    ////	// Optimize zero-based operations which cannot be optimized at expression level
    //    ////	//
    //    ////	if (oper == Operator.Subtraction) {
    //    ////		var lc = leftOperand as IntegralConstant;
    //    ////		if (lc != null && lc.IsDefaultValue) {
    //    ////			rightOperand.Emit(context);
    //    ////			context.Emit(OpCodes.Neg);
    //    ////			return;
    //    ////		}
    //    ////	}

    //    ////	EmitOperator(context, leftOperand, rightOperand);
    //    ////}

    //    ////public void EmitOperator(EmitContext context, Expression leftOperand, Expression rightOperand) {
    //    ////	leftOperand.Emit(context);
    //    ////	rightOperand.Emit(context);

    //    ////	EmitOperatorOpcode(context, oper, leftOperand.resovledType, rightOperand);

    //    ////	//
    //    ////	// Emit result enumerable conversion this way because it's quite complicated get it
    //    ////	// to resolved tree because expression tree cannot see it.
    //    ////	//
    //    ////	if (enum_conversion != 0)
    //    ////		ConvCast.Emit(context, enum_conversion);
    //    ////}

    //    ////public override void EmitSideEffect(EmitContext context) {
    //    ////	if ((oper & Operator.LogicalMask) != 0 ||
    //    ////		(context.HasSet(EmitContext.Options.CheckedScope) && (oper == Operator.Multiply || oper == Operator.Addition || oper == Operator.Subtraction))) {
    //    ////		base.EmitSideEffect(context);
    //    ////	} else {
    //    ////		leftOperand.EmitSideEffect(context);
    //    ////		rightOperand.EmitSideEffect(context);
    //    ////	}
    //    ////}

    //    ////public override Expression EmitToField(EmitContext context) {
    //    ////	if ((oper & Operator.LogicalMask) == 0) {
    //    ////		var await_expr = leftOperand as Await;
    //    ////		if (await_expr != null && rightOperand.IsSideEffectFree) {
    //    ////			await_expr.Statement.EmitPrologue(context);
    //    ////			leftOperand = await_expr.Statement.GetResultExpression(context);
    //    ////			return this;
    //    ////		}

    //    ////		await_expr = rightOperand as Await;
    //    ////		if (await_expr != null && leftOperand.IsSideEffectFree) {
    //    ////			await_expr.Statement.EmitPrologue(context);
    //    ////			rightOperand = await_expr.Statement.GetResultExpression(context);
    //    ////			return this;
    //    ////		}
    //    ////	}

    //    ////	return base.EmitToField(context);
    //    ////}


    //}

    //#endregion

    //#endregion

    //#region 语句

    //#region Statement

    ///// <summary>
    ///// 所有的语句的抽象基类。
    ///// </summary>
    //public abstract partial class Statement : Node {

    //    #region 空语句

    //    partial class EmptyStatement : Semicolon {

    //        /// <summary>
    //        /// 对当前语句执行语义分析。
    //        /// </summary>
    //        /// <param name="context">用于存储所有解析状态的上下文对象。</param>
    //        public override void resovle(ResolveContext context) {

    //        }

    //        /// <summary>
    //        /// 报告当前节点不可访问的警告。
    //        /// </summary>
    //        /// <returns>如果已输出警告信息则返回 true，否则返回 false。</returns>
    //        public override bool reportUnreachableCodeWarning() {
    //            return false;
    //        }

    //        ///// <summary>
    //        ///// 生成当前节点的代码。
    //        ///// </summary>
    //        ///// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //        //public override void emit(EmitContext context) {
    //        //    context.emitNoOperation();
    //        //}


    //    }

    //    #endregion

    //    /// <summary>
    //    /// 对当前语句执行语义分析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析状态的上下文对象。</param>
    //    public abstract void resovle(ResolveContext context);

    //}

    ///// <summary>
    ///// 表示一个空语句。
    ///// </summary>
    //public partial class Semicolon : Statement {

    //    public override void resovle(ResolveContext context) {
    //        throw new NotImplementedException();
    //    }
    //}

    //#endregion

    //#region Blocks

    ///// <summary>
    ///// 表示一个语句块。
    ///// </summary>
    //public partial class Block : Statement {




    //    Dictionary<string, LabeledStatement> _labels;

    //    /// <summary>
    //    /// 获取当前块内指定名字的第一个标签语句。
    //    /// </summary>
    //    /// <param name="name"></param>
    //    /// <returns></returns>
    //    public LabeledStatement getLabel(string name) {
    //        LabeledStatement ret;
    //        return _labels != null && _labels.TryGetValue(name, out ret) ? ret : null;
    //    }

    //    /// <summary>
    //    /// 记录当前语句块内是否跳转了。
    //    /// </summary>
    //    public bool isJumped;

    //    /// <summary>
    //    /// 对当前语句列表执行语义分析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析状态的上下文对象。</param>
    //    protected void resovleStatements(ResolveContext context) {

    //        bool enteredScope = false;

    //        // 初始化内部的标签和变量列表。
    //        for (int i = 0; i < statements.Count; i++) {
    //            Statement s = statements[i];
    //            var vs = s as VariableStatement;

    //            if (vs != null) {
    //                if (!enteredScope) {
    //                    context.enterScope();
    //                    enteredScope = true;
    //                }

    //                for (var variable = vs.variables; variable != null; variable = variable.next) {
    //                    variable.index = context.variableCount++;
    //                    context.currentScope.addVariable(variable);
    //                }
    //            }

    //            var ls = s as LabeledStatement;
    //            if (ls != null) {

    //                // 嵌套标签语句需要拆为两个。因为下面的逻辑标签语句只能为独立语句。
    //                if (ls.body is LabeledStatement) {
    //                    statements.Insert(i + 1, ls.body);
    //                    ls.body = Statement.empty;
    //                }

    //                if (_labels == null) {
    //                    _labels = new Dictionary<string, LabeledStatement>();
    //                } else if (_labels.ContainsKey(ls.label.value)) {
    //                    continue;
    //                }

    //                _labels[ls.label.value] = ls;
    //            }
    //        }

    //        // 进入执行分支。
    //        context.enterFlowBranching(new ResolveContext.BlockFlowBranching(context.currentBranching, this));

    //        bool wasNotJumped = !context.currentBranching.currentSibling.isJumped;

    //        // 解析块内的所有语句
    //        for (int len = statements.Count, i = 0; i < len; i++) {

    //            // 判断之前的语句是否已跳出，如果已跳出则之后的语句不能正常执行。
    //            if (context.currentBranching.currentSibling.isJumped) {

    //                // 之后的语句都不会执行，除非是标签语句通过 goto 执行。
    //                // 依次扫描并执行被 goto 到的语句，最后剩下的语句都是不可执行的。

    //                // 没有标签语句，加速处理。
    //                if (_labels == null) {

    //                    for (; i < len; i++) {
    //                        if (wasNotJumped && statements[i].reportUnreachableCodeWarning()) {
    //                            wasNotJumped = false;
    //                        }
    //                        statements[i].resovle(context);
    //                    }

    //                    break;
    //                }

    //                // 有标签语句，需要检测其最终的可访问性。
    //                Statement[] left = new Statement[len - i];
    //                statements.CopyTo(i, left, 0, left.Length);

    //                // 标记是否有新的语句被重新执行。
    //                bool hasNewLabelReached;

    //                do {
    //                    hasNewLabelReached = false;
    //                    for (int j = 0; j < left.Length; j++) {
    //                        LabeledStatement ls = left[j] as LabeledStatement;
    //                        if (ls != null && ls.isEverUsed) {
    //                            hasNewLabelReached = true;

    //                            // 依次执行之后的语句直到重新跳转或语句结束。
    //                            do {

    //                                // 执行语句。
    //                                left[j].resovle(context);

    //                                // 清空已执行的语句。
    //                                left[j] = null;

    //                            } while (++j < left.Length && left[j] != null && !context.currentBranching.currentSibling.isJumped);

    //                        }
    //                    }
    //                } while (hasNewLabelReached);

    //                // 所有能执行的语句都执行完毕，剩下的是不能执行的语句，报告不可访问的错误。
    //                for (int j = 0; j < left.Length; j++) {
    //                    if (left[j] != null) {
    //                        if (wasNotJumped && left[j].reportUnreachableCodeWarning()) {
    //                            wasNotJumped = false;
    //                        }
    //                        left[j].resovle(context);
    //                    }
    //                }

    //                // 一切操作完成，直接退出即可。
    //                break;

    //            }

    //            // 执行语句本身。
    //            statements[i].resovle(context);

    //        }

    //        // 退出所有的标签分支。
    //        while (context.currentBranching is ResolveContext.LabeledFlowBranching)
    //            context.exitFlowBranching();

    //        // 退出执行分支。
    //        context.exitFlowBranching();

    //        //isJumped = context.currentBranching.currentSibling.isJumped;

    //        //// 检查全部标签是否都被使用。
    //        //if (_labels != null) {
    //        //	foreach (var label in _labels) {
    //        //		if (!label.Value.isEverUsed) {
    //        //			Compiler.warning(1, String.Format("标签“{0}”从未使用过", label.Key), label.Value.label);
    //        //		}
    //        //	}
    //        //}

    //        // 检查变量是否都被使用。
    //        if (enteredScope) {
    //            context.exitScope();
    //        }

    //    }

    //    /// <summary>
    //    /// 对当前语句执行语义分析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析状态的上下文对象。</param>
    //    /// <returns>返回解析后的新语句，它的所有子语句都已经被解析。如果解析出现错误则返回 null 。</returns>
    //    public override void resovle(ResolveContext context) {
    //        if (statements != null) {
    //            resovleStatements(context);
    //        }
    //    }

    //    /// <summary>
    //    /// 报告当前节点不可访问的警告。
    //    /// </summary>
    //    /// <returns>如果已输出警告信息则返回 true，否则返回 false。</returns>
    //    public override bool reportUnreachableCodeWarning() {
    //        if (statements != null) {
    //            for (int i = 0; i < statements.Count; i++) {
    //                if (statements[i].reportUnreachableCodeWarning()) {
    //                    return true;
    //                }
    //            }
    //        }
    //        return false;
    //    }

    //    ///// <summary>
    //    ///// 生成当前节点的代码。
    //    ///// </summary>
    //    ///// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //    //public override void emit(EmitContext context) {
    //    //    context.markLocation(startLocation, startLocation + 1);
    //    //    foreach (var statement in statements) {
    //    //        statement.emit(context);
    //    //    }
    //    //    context.markLocation(endLocation, endLocation + 1);
    //    //}


    //}

    ///// <summary>
    ///// 表示一个最顶层的语句块。
    ///// </summary>
    //public partial class ToplevelBlock : Block {


    //    /// <summary>
    //    /// 获取或设置当前顶级块的预设参数。
    //    /// </summary>
    //    public Parameter parameters;

    //    /// <summary>
    //    /// 当前模块的输出参数列表。
    //    /// </summary>
    //    public List<Parameter> outParameters;

    //    ///// <summary>
    //    ///// 对当前语句执行语义分析。
    //    ///// </summary>
    //    ///// <param name="context">用于存储所有解析状态的上下文对象。</param>
    //    //public override void resovle(ResolveContext context) {
    //    //    resovle(context, null);
    //    //}

    //    //bool isJumped;

    //    ///// <summary>
    //    ///// 对当前语句快所有语句执行语义分析。
    //    ///// </summary>
    //    ///// <param name="context">用于存储所有解析状态的上下文对象。</param>
    //    //public void resovle(ResolveContext context, ResolveContext.FlowBranching parent) {

    //    //    if (statements != null) {

    //    //        // 1. 初始化参数和变量的赋值状态。

    //    //        // 创建全局作用域。
    //    //        context.enterScope();

    //    //        int parametersCount = 0;

    //    //        // 处理参数。
    //    //        for (var parameter = parameters; parameter != null; parameter = (Parameter)parameter.next) {
    //    //            if (parameter.variableType == Variable.VariableType.outParameter) {
    //    //                parameter.index = context.variableCount++;
    //    //                if (outParameters == null) {
    //    //                    outParameters = new List<Parameter>();
    //    //                }
    //    //                outParameters.Add(parameter);
    //    //            }

    //    //            parameter.parameterIndex = parametersCount++;
    //    //            context.currentScope.addVariable(parameter);
    //    //        }


    //    //        // 2. 进入执行分支。
    //    //        context.enterFlowBranching(new ResolveContext.ToplevelFlowBranching(parent, this));

    //    //        // 3. 执行所有语句。
    //    //        resovleStatements(context);

    //    //        // 4. 退出执行分支。
    //    //        isJumped = context.currentBranching.merge().isJumped;
    //    //        context.exitFlowBranchingWithoutSave();

    //    //    }

    //    //    // 非 void 返回的函数必须返回一个值。
    //    //    if (!isJumped && context.returnType != PredefinedTypes.@void) {
    //    //        Compiler.error(1, "并非所有的执行分支都有返回值", context.containerMemberDefinition.name);
    //    //    }

    //    //}


    //    //#region 生成

    //    ///// <summary>
    //    ///// 生成当前节点的代码。
    //    ///// </summary>
    //    ///// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //    //public override void emit(EmitContext context) {

    //    //    if (statements != null) {
    //    //        base.emit(context);
    //    //    }

    //    //    // 如果有语句需要跳到末尾，则标记末尾。
    //    //    if (context.returnLabel.HasValue) {
    //    //        context.markLabel(context.returnLabel.Value);
    //    //        context.returnLabel = null;

    //    //        context.emitReturn();
    //    //    } else if (!isJumped) {
    //    //        context.emitReturn();
    //    //    }

    //    //}


    //}

    //#endregion

    //#region ShimStatements


    ///// <summary>
    ///// 表示一个变量声明语句。
    ///// </summary>
    //public partial class VariableStatement : Statement {

    //    /// <summary>
    //    /// 对当前语句执行语义分析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析状态的上下文对象。</param>
    //    public override void resovle(ResolveContext context) {
    //        for (var variable = this.variables; variable != null; variable = variable.next) {
    //            variable.resovle(context);
    //        }
    //    }

    //    ///// <summary>
    //    ///// 生成当前节点的代码。
    //    ///// </summary>
    //    ///// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //    //public override void emit(EmitContext context) {
    //    //    bool first = false;
    //    //    for (var variable = this.variables; variable != null; variable = variable.next) {
    //    //        if (first) {
    //    //            context.markLocation(variable.type.startLocation, variable.endLocation);
    //    //            first = false;
    //    //        } else {
    //    //            context.markLocation(variable.startLocation, variable.endLocation);
    //    //        }

    //    //        variable.emit(context);
    //    //    }
    //    //}

    //}

    ///// <summary>
    ///// 表示一个标签语句。
    ///// </summary>
    //public partial class LabeledStatement : Statement {

    //    /// <summary>
    //    /// 用于存储跳转到当前语句之前的分支信息。
    //    /// </summary>
    //    public ResolveContext.FlowBranching.SiblingInfo sibling;

    //    /// <summary>
    //    /// 标记当前标签语句是否已声明。
    //    /// </summary>
    //    public bool isDeclared;

    //    //public bool isUsed {
    //    //	get {
    //    //		return status == GotoStatement.LabelStatus.reached;
    //    //	}
    //    //}

    //    /// <summary>
    //    /// 获取或设置当前标签语句的状态。
    //    /// </summary>
    //    public State status;

    //    public bool isEverUsed;

    //    public bool wasJumped;

    //    /// <summary>
    //    /// 对当前语句执行语义分析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析状态的上下文对象。</param>
    //    /// <returns>
    //    /// 返回解析后的新语句，它的所有子语句都已经被解析。如果解析出现错误则返回 null 。
    //    /// </returns>
    //    public override void resovle(ResolveContext context) {

    //        #region 判断标签名

    //        // 如果标签已经标记解析了，说明是子级同名标签解析的。
    //        if (isDeclared) {
    //            Compiler.error(1, String.Format("不能使用“{0}”作为标签名, 因为它已经在子级范围出现过了", label.value), this);
    //            return;
    //        }

    //        var found = context.currentBranching.findLabel(label.value);
    //        if (found != this) {
    //            Compiler.error(1, String.Format("不能使用“{0}”作为标签名, 因为它已经在当前或父级范围出现过了", label.value), this);
    //            return;
    //        }

    //        // 解析标签是否合法。
    //        isDeclared = true;

    //        #endregion

    //        // Label 语句不需要在这里退出。
    //        context.enterFlowBranching(new ResolveContext.LabeledFlowBranching(context.currentBranching, this));

    //        body.resovle(context);
    //    }

    //    //public System.Reflection.Emit.Label? labelTarget;

    //    ///// <summary>
    //    ///// 生成当前节点的代码。
    //    ///// </summary>
    //    ///// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //    //public override void emit(EmitContext context) {
    //    //    if (!labelTarget.HasValue) {
    //    //        labelTarget = context.createLabel();
    //    //    }
    //    //    context.markLabel(labelTarget.Value);
    //    //    body.emit(context);
    //    //}


    //}

    ///// <summary>
    ///// 表示一个 assert 语句。
    ///// </summary>
    //public partial class AssertStatement : Statement {

    //    /// <summary>
    //    /// 对当前语句执行语义分析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析状态的上下文对象。</param>
    //    public override void resovle(ResolveContext context) {
    //        //Compiler.notImplement(this);
    //    }

    //    ///// <summary>
    //    ///// 生成当前节点的代码。
    //    ///// </summary>
    //    ///// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //    //public override void emit(EmitContext context) {
    //    //    Compiler.notImplement(this);
    //    //}

    //}

    ///// <summary>
    ///// 表示一个调试输出语句。
    ///// </summary>
    //public partial class TraceStatement : Statement {

    //    /// <summary>
    //    /// 对当前语句执行语义分析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析状态的上下文对象。</param>
    //    /// <returns>
    //    /// 返回解析后的新语句，它的所有子语句都已经被解析。如果解析出现错误则返回 null 。
    //    /// </returns>
    //    public override void resovle(ResolveContext context) {
    //        // Compiler.notImplement(this);
    //        //arguments.write(writer);

    //        //for (int i = 0; i < arguments.Count; i++) {
    //        //	arguments[i] = arguments[i].resolveAsValue(context);
    //        //}
    //    }

    //    ///// <summary>
    //    ///// 生成当前节点的代码。
    //    ///// </summary>
    //    ///// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //    //public override void emit(EmitContext context) {

    //    //    Compiler.notImplement(this);

    //    //    return;

    //    //    //if (arguments != null) {

    //    //    //	arguments[0].emit(context);

    //    //    //	//context.emitCallVirtual(typeof(Object).GetMethod("ToString"));

    //    //    //	context.emitCallStatic(typeof(Console).GetMethod("WriteLine", new Type[] { typeof(int) }));

    //    //    //}

    //    //    //context.emitCallStatic(typeof(Console).GetMethod("ReadLine", new Type[] { }));

    //    //    //context.emitPop();

    //    //}

    //}

    ///// <summary>
    ///// 表示一个表达式语句。
    ///// </summary>
    //public partial class ExpressionStatement : Statement {

    //    /// <summary>
    //    /// 对当前语句执行语义分析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析状态的上下文对象。</param>
    //    /// <returns>
    //    /// 返回解析后的新语句，它的所有子语句都已经被解析。如果解析出现错误则返回 null 。
    //    /// </returns>
    //    public override void resovle(ResolveContext context) {
    //        body = body.resolveAsValue(context);
    //        var assignmemt = body as AssignmemtExpression;
    //        if (assignmemt != null) {

    //            // 赋值操作不需要任何返回值。
    //            assignmemt.returnVoid = true;
    //        }
    //    }

    //    ///// <summary>
    //    ///// 生成当前节点的代码。
    //    ///// </summary>
    //    ///// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //    //public override void emit(EmitContext context) {
    //    //    body.emit(context);
    //    //    if (body.resolvedType != PredefinedTypes.@void) {
    //    //        context.emitPop();
    //    //    }
    //    //}

    //}

    ///// <summary>
    ///// 表示一组逗号隔开的表达式。
    ///// </summary>
    //public partial class ChainedExpressionStatement : ExpressionStatement {

    //    /// <summary>
    //    /// 对当前语句执行语义分析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析状态的上下文对象。</param>
    //    public override void resovle(ResolveContext context) {
    //        // Compiler.notImplement(this);
    //    }

    //    ///// <summary>
    //    ///// 生成当前节点的代码。
    //    ///// </summary>
    //    ///// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //    //public override void emit(EmitContext context) {
    //    //    Compiler.notImplement(this);
    //    //}


    //}

    ///// <summary>
    ///// 表示一个 runonce 语句。
    ///// </summary>
    //public partial class RunonceStatement : Statement {

    //    /// <summary>
    //    /// 对当前语句执行语义分析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析状态的上下文对象。</param>
    //    public override void resovle(ResolveContext context) {
    //        //Compiler.notImplement(this);
    //    }

    //    ///// <summary>
    //    ///// 生成当前节点的代码。
    //    ///// </summary>
    //    ///// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //    //public override void emit(EmitContext context) {
    //    //    Compiler.notImplement(this);
    //    //}

    //}

    ///// <summary>
    ///// 表示一个 checked 语句。
    ///// </summary>
    //public partial class CheckedStatement : Statement {

    //    /// <summary>
    //    /// 对当前语句执行语义分析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析状态的上下文对象。</param>
    //    public override void resovle(ResolveContext context) {
    //        context.isChecked = true;
    //        body.resovle(context);
    //    }

    //    ///// <summary>
    //    ///// 生成当前节点的代码。
    //    ///// </summary>
    //    ///// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //    //public override void emit(EmitContext context) {
    //    //    Compiler.notImplement(this);
    //    //}


    //}

    ///// <summary>
    ///// 表示一个 unchecked 语句。
    ///// </summary>
    //public partial class UncheckedStatement : Statement {

    //    /// <summary>
    //    /// 对当前语句执行语义分析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析状态的上下文对象。</param>
    //    public override void resovle(ResolveContext context) {
    //        context.isChecked = false;
    //        body.resovle(context);
    //    }

    //    ///// <summary>
    //    ///// 生成当前节点的代码。
    //    ///// </summary>
    //    ///// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //    //public override void emit(EmitContext context) {
    //    //    Compiler.notImplement(this);
    //    //}

    //}

    ///// <summary>
    ///// 表示一个 lock 语句。
    ///// </summary>
    //public partial class LockStatement : Statement {

    //    /// <summary>
    //    /// 对当前语句执行语义分析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析状态的上下文对象。</param>
    //    public override void resovle(ResolveContext context) {
    //        //Compiler.notImplement(this);
    //    }

    //    //#region 生成

    //    ///// <summary>
    //    ///// 生成当前节点的代码。
    //    ///// </summary>
    //    ///// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //    //public override void emit(EmitContext context) {
    //    //    Compiler.notImplement(this);
    //    //}

    //}

    ///// <summary>
    ///// 表示一个可调试语句。
    ///// </summary>
    //public partial class WithStatement : Statement {

    //    /// <summary>
    //    /// 对当前语句执行语义分析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析状态的上下文对象。</param>
    //    public override void resovle(ResolveContext context) {
    //        //Compiler.notImplement(this);
    //    }

    //    ///// <summary>
    //    ///// 生成当前节点的代码。
    //    ///// </summary>
    //    ///// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //    //public override void emit(EmitContext context) {
    //    //    Compiler.notImplement(this);
    //    //}


    //}

    //#endregion

    //#region SelectionStatements

    ///// <summary>
    ///// 表示一个 if 语句。
    ///// </summary>
    //public partial class IfStatement : Statement {

    //    /// <summary>
    //    /// 获取或设置当前则语句部分是否包含了跳转的语句。
    //    /// </summary>
    //    public bool isJumpedInThenClause;

    //    /// <summary>
    //    /// 对当前语句执行语义分析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析状态的上下文对象。</param>
    //    /// <returns>返回解析后的新语句，它的所有子语句都已经被解析。如果解析出现错误则返回 null 。</returns>
    //    public override void resovle(ResolveContext context) {

    //        // 执行判断部分。
    //        if ((condition = (BooleanExpression)condition.resolveAsValue(context)) == null) {
    //            return;
    //        }

    //        // 进入执行分支。
    //        context.enterFlowBranching(new ResolveContext.FlowBranching(context.currentBranching));

    //        // 执行 if 段。

    //        // 判断是否永远不执行。
    //        if (condition.resolvedValue == State.off && !context.currentBranching.currentSibling.isJumped) {
    //            thenClause.reportUnreachableCodeWarning();
    //            context.currentBranching.currentSibling.isJumped = true;
    //        }

    //        thenClause.resovle(context);

    //        // 记录当前 if 内是否有跳转。
    //        // 如果有跳转，则 if 不需要自己跳转到 else 末尾。
    //        isJumpedInThenClause = context.currentBranching.currentSibling.isJumped;

    //        // 执行 else 段。
    //        context.currentBranching.createSibling();
    //        if (elseClause != null) {

    //            // 判断是否永远不执行。
    //            if (condition.resolvedValue == State.on && !context.currentBranching.currentSibling.isJumped) {
    //                elseClause.reportUnreachableCodeWarning();
    //                context.currentBranching.currentSibling.isJumped = true;
    //            }

    //            elseClause.resovle(context);
    //        } else if (condition.resolvedValue == State.on) {
    //            context.currentBranching.currentSibling.isJumped = true;
    //        }

    //        // 退出执行分支。
    //        context.exitFlowBranching();

    //    }

    //    ///// <summary>
    //    ///// 生成当前节点的代码。
    //    ///// </summary>
    //    ///// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //    //public override void emit(EmitContext context) {

    //    //    condition.emit(context);

    //    //    var thenLabel = context.emitBranchIfFalse();
    //    //    thenClause.emit(context);

    //    //    if (elseClause != null) {

    //    //        // 如果 if 没有跳转，需要强制跳转到末尾。
    //    //        var endLabel = isJumpedInThenClause ? new System.Reflection.Emit.Label() : context.emitBranch();

    //    //        context.markLabel(thenLabel);
    //    //        elseClause.emit(context);

    //    //        if (!isJumpedInThenClause) {
    //    //            context.markLabel(endLabel);
    //    //        }

    //    //    } else {
    //    //        context.markLabel(thenLabel);
    //    //    }

    //    //}

    //}

    ///// <summary>
    ///// 表示一个 switch 语句。
    ///// </summary>
    //public partial class SwitchStatement : Statement {

    //    public partial class CaseClause : Node {

    //        /// <summary>
    //        /// 获取当前 case 关联的其它 case 。
    //        /// </summary>
    //        public CaseClause chainedCase;

    //        /// <summary>
    //        /// 用于存储跳转到当前语句之前的分支信息。
    //        /// </summary>
    //        public ResolveContext.FlowBranching.SiblingInfo sibling;

    //        /// <summary>
    //        /// 获取当前 case 解析后返回的常量值。
    //        /// </summary>
    //        public object labelValue;

    //        public System.Reflection.Emit.Label labelTarget;

    //        //public bool isUsed {
    //        //	get {
    //        //		return status != GotoStatement.LabelStatus.unreached;
    //        //	}
    //        //}

    //        public bool isEverUsed;

    //    }

    //    static readonly TypeReference[] _acceptedSwitchTypes = new TypeReference[] {
    //        PredefinedTypes.@int,
    //        PredefinedTypes.@bool,
    //    };

    //    /// <summary>
    //    /// 对当前语句执行语义分析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析状态的上下文对象。</param>
    //    /// <returns>返回解析后的新语句，它的所有子语句都已经被解析。如果解析出现错误则返回 null 。</returns>
    //    public override void resovle(ResolveContext context) {

    //        #region 执行 condition

    //        // 存储解析前的表达式，用于报错。
    //        if ((expression = (StatementExpression)expression.resolveAsValue(context)) == null) {
    //            return;
    //        }

    //        TypeReference conditionType = expression.resolvedType;

    //        // 不是合法的 switch 类型，先尝试隐性转换类型。
    //        if (false && conditionType.memberType != MemberType.@enum && Array.IndexOf(_acceptedSwitchTypes, conditionType) <= 0) {
    //            // todo: 隐式转换类型。

    //            Compiler.error(1, String.Format("switch 表达式中不允许使用类型 {0}", conditionType.fullName), expression);
    //            return;
    //        }

    //        object conditionValue;
    //        bool conditionValueIsKnown = expression.tryEval(context, out conditionValue);

    //        #endregion

    //        #region 预处理 caseClause.label

    //        // 优化空 switch。
    //        if (caseClauses == null) {
    //            Compiler.warning(1, "空的 switch 块", this);
    //            return;
    //        }

    //        // 存储 else 分支。
    //        CaseClause caseElse = null;
    //        int errorCount = Compiler.errorCount;

    //        for (var caseClause = caseClauses; caseClause != null; caseClause = caseClause.next) {

    //            if (caseClause.label != null) {

    //                // 处理 label 。
    //                if ((caseClause.label = caseClause.label.resolveAsValue(context)) == null) {
    //                    continue;
    //                }

    //                // 判断是否常量。
    //                if (!caseClause.label.tryEval(context, out caseClause.labelValue)) {
    //                    Compiler.error(1, "无法在编译时计算 case 表达式的值", caseClause);
    //                    continue;
    //                }

    //                // 判断类型是否合法。
    //                if (conditionType != caseClause.label.resolvedType) {
    //                    Compiler.error(1, String.Format("case 之后的表达式应该返回类型“{0}”", conditionType.fullName), caseClause);
    //                    continue;
    //                }

    //                // 判断重复性。
    //                for (var caseClause2 = caseClauses; caseClause2 != caseClause; caseClause2 = caseClause2.next) {
    //                    if (caseClause2.labelValue.ToString() == caseClause.labelValue.ToString()) {
    //                        Compiler.error(1, "当前 switch 语句已经包含了相同的 case", caseClause);
    //                        break;
    //                    }
    //                }

    //            } else {

    //                // 判断重复性。
    //                if (caseElse != null) {
    //                    Compiler.error(1, "当前 switch 语句已经包含了 case else", caseClause);
    //                    continue;
    //                }

    //                caseElse = caseClause;

    //            }
    //        }

    //        // 处理标签存在错误。
    //        if (Compiler.errorCount > errorCount) {
    //            return;
    //        }

    //        #endregion

    //        #region 执行主体

    //        // 进入执行分支。
    //        context.enterFlowBranching(new ResolveContext.SwitchFlowBranching(context.currentBranching, this));

    //        // 常量特殊处理。
    //        if (conditionValueIsKnown) {

    //            // 找出满足要求的 case。
    //            CaseClause selectedCase = caseElse;
    //            List<CaseClause> otherCases = new List<CaseClause>();
    //            for (var caseClause = caseClauses; caseClause != null; caseClause = caseClause.next) {

    //                // 值相等，说明这是需要找的 case 。
    //                if (caseClause.label != null && caseClause.labelValue.ToString() == conditionValue.ToString()) {
    //                    selectedCase = caseClause;
    //                    continue;
    //                }

    //                if (caseClause.body != null) {
    //                    otherCases.Add(caseClause);
    //                }
    //            }

    //            // 如果没有匹配任何分支直接退出。
    //            if (selectedCase == null) {
    //                Compiler.warning(1, "检测到永远不会执行 switch 语句的任何一个 case 分支", this);
    //                context.exitFlowBranchingWithoutSave();
    //                return;
    //            }

    //            // 如果当前匹配了 caseElse 。
    //            bool selectedCaseIsElse = selectedCase == caseElse;

    //            // 使用有语句的 case 。
    //            while (selectedCase.body == null) {
    //                selectedCase = selectedCase.next;
    //            }

    //            // 删除 else 分支。
    //            if (selectedCaseIsElse) {
    //                otherCases.Remove(selectedCase);
    //            }

    //            // 记住之前的执行状态以备使用。
    //            bool wasNotJumped = !context.currentBranching.currentSibling.isJumped;

    //            // 执行选中的分支。
    //            selectedCase.body.resovle(context);

    //            // 查找是否有其它的 case 被激活执行。
    //            bool hasNewCaseReached;

    //            do {
    //                hasNewCaseReached = false;
    //                for (int i = 0; i < otherCases.Count; i++) {
    //                    if (otherCases[i] != null && otherCases[i].isEverUsed) {
    //                        hasNewCaseReached = true;
    //                        context.currentBranching.createSibling();
    //                        if (otherCases[i].sibling != null) {
    //                            context.currentBranching.currentSibling.orVariableAssignmentInfos(otherCases[i].sibling);
    //                            context.currentBranching.currentSibling.isJumped = otherCases[i].sibling.isJumped;
    //                            // 重用信息。
    //                            otherCases[i].sibling = null;
    //                        }
    //                        otherCases[i].body.resovle(context);
    //                        otherCases[i] = null;
    //                    }
    //                }
    //            } while (hasNewCaseReached);

    //            for (int i = 0; i < otherCases.Count; i++) {
    //                if (otherCases[i] != null) {
    //                    if (wasNotJumped && otherCases[i].reportUnreachableCodeWarning()) {
    //                        wasNotJumped = false;
    //                    }
    //                    context.currentBranching.createSibling();
    //                    context.currentBranching.currentSibling.isJumped = true;
    //                    otherCases[i].body.resovle(context);
    //                }
    //            }

    //            context.exitFlowBranching();
    //            return;

    //        }

    //        bool requireANewSibling = false;
    //        for (var caseClause = caseClauses; caseClause != null; caseClause = caseClause.next) {
    //            if (caseClause.body != null) {
    //                if (requireANewSibling) {
    //                    context.currentBranching.createSibling();
    //                } else {
    //                    requireANewSibling = true;
    //                }

    //                caseClause.body.resovle(context);
    //            }
    //        }

    //        // 如果没有 case else 段，则 switch 的信息都不需要保存。
    //        if (caseElse == null)
    //            context.exitFlowBranchingWithoutSave();
    //        else
    //            context.exitFlowBranching();

    //        #endregion

    //    }

    //    /// <summary>
    //    /// 获取一个 case 从句。
    //    /// </summary>
    //    /// <param name="p"></param>
    //    /// <returns></returns>
    //    public CaseClause getCase(object labelValue) {
    //        for (var caseClause = caseClauses; caseClause != null; caseClause = caseClause.next) {
    //            if (caseClause.labelValue.ToString() == labelValue.ToString()) {
    //                return caseClause;
    //            }
    //        }
    //        return null;
    //    }

    //    ///// <summary>
    //    ///// 生成当前节点的代码。
    //    ///// </summary>
    //    ///// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //    //public override void emit(EmitContext context) {


    //    //    Compiler.notImplement(this);
    //    //    return;

    //    //    if (expression == null) {
    //    //        Compiler.notImplement(this);
    //    //        return;
    //    //    }

    //    //    if (caseClauses == null) {
    //    //        expression.emit(context);
    //    //        context.emitPop();
    //    //        return;
    //    //    }

    //    //    var end = context.createLabel();

    //    //    expression.emit(context);

    //    //    CaseClause elseCase;

    //    //    //for (var i = caseClauses.Count; --i >= 0; ) {
    //    //    //    if (caseClauses[i].chainedCase != null) {
    //    //    //        caseClauses[i].labelTarget = caseClauses[i].chainedCase.labelTarget;
    //    //    //    } else {
    //    //    //        caseClauses[i].labelTarget = context.createLabel();
    //    //    //    }

    //    //    //    if (caseClauses[i].label == null) {
    //    //    //        if (caseClauses[i].body != null)
    //    //    //            elseCase = caseClauses[i];
    //    //    //    } else {
    //    //    //        caseClauses[i].label.emit(context);
    //    //    //        context.emitBranchIfEqual(caseClauses[i].labelTarget);
    //    //    //    }
    //    //    //}

    //    //    //foreach (var caseClause in caseClauses) {
    //    //    //    if (caseClause.body == null) {

    //    //    //    }

    //    //    //    caseClause.labelTarget = context.createLabel();

    //    //    //    if (caseClause.label == null) {
    //    //    //        elseCase = caseClause;
    //    //    //    } else {
    //    //    //        caseClause.label.emit(context);
    //    //    //    }
    //    //    //}

    //    //    //foreach (var caseClause in caseClauses) {
    //    //    //    context.markLabel(caseClause.labelTarget);

    //    //    //    //caseClause.label

    //    //    //    caseClause.body.emit(context);
    //    //    //    context.emitBranchShort(end);
    //    //    //}

    //    //    //System.Reflection.Emit.Label[] labels = new System.Reflection.Emit.Label[caseClauses.Count];


    //    //    //context.emitSwitch(labels);

    //    //    //defaultLabel = case_default == null ? context.LoopEnd : case_default.GetILLabel(context);
    //    //    //nullLabel = case_null == null ? defaultLabel : case_null.GetILLabel(context);

    //    //    //if (value != null) {
    //    //    //	context.Mark(_startLocation);
    //    //    //	if (IsNullable) {
    //    //    //		unwrap.EmitCheck(context);
    //    //    //		context.Emit(OpCodes.Brfalse, nullLabel);
    //    //    //		value.EmitAssign(context, new_expr, false, false);
    //    //    //	} else if (new_expr != value) {
    //    //    //		value.EmitAssign(context, new_expr, false, false);
    //    //    //	}


    //    //    //	//
    //    //    //	// Next statement is compiler generated we don't need extra
    //    //    //	// nop when we can use the statement for sequence point
    //    //    //	//
    //    //    //	context.Mark(block.StartLocation);
    //    //    //	block.IsCompilerGenerated = true;
    //    //    //}

    //    //    //block.Emit(context);

    //    //    //// Restore context state. 
    //    //    //context.MarkLabel(context.LoopEnd);

    //    //    ////
    //    //    //// Restore the previous context
    //    //    ////
    //    //    //context.LoopEnd = old_end;
    //    //    //context.Switch = old_switch;
    //    //}

    //}

    //#endregion

    //#region JumpStatements

    ///// <summary>
    ///// 表示一个 continue 语句。
    ///// </summary>
    //public partial class ContinueStatement : Statement {

    //    public bool leavesTry;

    //    /// <summary>
    //    /// 对当前语句执行语义分析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析状态的上下文对象。</param>
    //    /// <returns>
    //    /// 返回解析后的新语句，它的所有子语句都已经被解析。如果解析出现错误则返回 null 。
    //    /// </returns>
    //    public override void resovle(ResolveContext context) {
    //        leavesTry = context.currentBranching.execContinue(context.currentBranching.currentSibling, this);
    //        context.currentBranching.currentSibling.isJumped = true;
    //    }

    //    ///// <summary>
    //    ///// 生成当前节点的代码。
    //    ///// </summary>
    //    ///// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //    //public override void emit(EmitContext context) {
    //    //    if (leavesTry) {
    //    //        context.emitLeave(context.loopBegin);
    //    //    } else {
    //    //        context.emitBranch(context.loopBegin);
    //    //    }
    //    //}

    //}

    ///// <summary>
    ///// 表示一个 break 语句。
    ///// </summary>
    //public partial class BreakStatement : Statement {

    //    public bool leavesTry;

    //    /// <summary>
    //    /// 对当前语句执行语义分析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析状态的上下文对象。</param>
    //    /// <returns>
    //    /// 返回解析后的新语句，它的所有子语句都已经被解析。如果解析出现错误则返回 null 。
    //    /// </returns>
    //    public override void resovle(ResolveContext context) {
    //        leavesTry = context.currentBranching.execBreak(context.currentBranching.currentSibling, this);
    //        context.currentBranching.currentSibling.isJumped = true;
    //    }

    //    ///// <summary>
    //    ///// 生成当前节点的代码。
    //    ///// </summary>
    //    ///// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //    //public override void emit(EmitContext context) {
    //    //    if (leavesTry) {
    //    //        context.emitLeave(context.loopEnd);
    //    //    } else {
    //    //        context.emitBranch(context.loopEnd);
    //    //    }
    //    //}

    //}

    ///// <summary>
    ///// 表示一个 return 语句。
    ///// </summary>
    //public partial class ReturnStatement : Statement {

    //    public bool leavesTry;

    //    /// <summary>
    //    /// 对当前语句执行语义分析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析状态的上下文对象。</param>
    //    /// <returns>返回解析后的新语句，它的所有子语句都已经被解析。如果解析出现错误则返回 null 。</returns>
    //    public override void resovle(ResolveContext context) {

    //        // 执行表达式。
    //        if (value != null) {
    //            value = value.resolveAsValue(context, context.returnType);
    //        } else if (context.returnType != PredefinedTypes.@void) {
    //            Compiler.error(1, String.Format("需要返回一个可以转换为类型“{0}”的对象", context.returnType.fullName), this);
    //        }

    //        // 执行 return 。
    //        leavesTry = context.currentBranching.execReturn(context.currentBranching.currentSibling, this);
    //        context.currentBranching.currentSibling.isJumped = true;
    //    }

    //    ///// <summary>
    //    ///// 生成当前节点的代码。
    //    ///// </summary>
    //    ///// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //    //public override void emit(EmitContext context) {
    //    //    if (value != null) {
    //    //        value.emit(context);
    //    //    }

    //    //    if (leavesTry) {
    //    //        if (!context.returnLabel.HasValue) {
    //    //            context.returnLabel = context.createLabel();
    //    //        }
    //    //        context.emitLeave(context.returnLabel.Value);
    //    //    } else {
    //    //        context.emitReturn();
    //    //    }
    //    //}

    //}

    ///// <summary>
    ///// 为不同形式的跳到语句提供抽象基类。
    ///// </summary>
    //public abstract partial class GotoStatement : Statement {

    //    /// <summary>
    //    /// 存储当前跳转是否离开了 try 段。
    //    /// </summary>
    //    public bool leavesTry;

    //}

    ///// <summary>
    ///// 表示一个跳转到标签的跳到语句。
    ///// </summary>
    //public partial class GotoLabelStatement : GotoStatement {

    //    /// <summary>
    //    /// 当前跳转的目标。
    //    /// </summary>
    //    public LabeledStatement resolvedTarget;

    //    /// <summary>
    //    /// 对当前语句执行语义分析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析状态的上下文对象。</param>
    //    /// <returns>
    //    /// 返回解析后的新语句，它的所有子语句都已经被解析。如果解析出现错误则返回 null 。
    //    /// </returns>
    //    public override void resovle(ResolveContext context) {
    //        leavesTry = context.currentBranching.execGoto(context.currentBranching.currentSibling, this);
    //        context.currentBranching.currentSibling.isJumped = true;
    //    }

    //    ///// <summary>
    //    ///// 生成当前节点的代码。
    //    ///// </summary>
    //    ///// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //    //public override void emit(EmitContext context) {

    //    //    if (!resolvedTarget.labelTarget.HasValue) {
    //    //        resolvedTarget.labelTarget = context.createLabel();
    //    //    }

    //    //    if (leavesTry) {
    //    //        context.emitLeave(resolvedTarget.labelTarget.Value);
    //    //    } else {
    //    //        context.emitBranch(resolvedTarget.labelTarget.Value);
    //    //    }

    //    //}

    //}

    ///// <summary>
    ///// 表示一个跳转到 case 语句的跳到语句。
    ///// </summary>
    //public partial class GotoCaseStatement : GotoStatement {

    //    public SwitchStatement.CaseClause resolvedTarget;

    //    public object labelValue;

    //    /// <summary>
    //    /// 对当前语句执行语义分析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析状态的上下文对象。</param>
    //    /// <returns>
    //    /// 返回解析后的新语句，它的所有子语句都已经被解析。如果解析出现错误则返回 null 。
    //    /// </returns>
    //    public override void resovle(ResolveContext context) {
    //        var label = target.resolveAsValue(context);
    //        if (label != null) {
    //            if (!label.tryEval(context, out labelValue)) {
    //                Compiler.error(1, "无法计算标签的值", target);
    //            } else {
    //                leavesTry = context.currentBranching.execGoto(context.currentBranching.currentSibling, this);
    //            }
    //        }

    //        context.currentBranching.currentSibling.isJumped = true;
    //    }

    //    ///// <summary>
    //    ///// 生成当前节点的代码。
    //    ///// </summary>
    //    ///// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //    //public override void emit(EmitContext context) {

    //    //    if (leavesTry) {
    //    //        context.emitLeave(resolvedTarget.labelTarget);
    //    //    } else {
    //    //        context.emitBranch(resolvedTarget.labelTarget);
    //    //    }

    //    //}

    //}

    ///// <summary>
    ///// 表示一个 yield continue 语句。
    ///// </summary>
    //public partial class YieldContinueStatement : ContinueStatement {

    //    /// <summary>
    //    /// 对当前语句执行语义分析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析状态的上下文对象。</param>
    //    public override void resovle(ResolveContext context) {
    //        //Compiler.notImplement(this);
    //        //context.currentBranching.jumped = true;
    //    }

    //    ///// <summary>
    //    ///// 生成当前节点的代码。
    //    ///// </summary>
    //    ///// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //    //public override void emit(EmitContext context) {
    //    //    Compiler.notImplement(this);
    //    //}

    //}

    ///// <summary>
    ///// 表示一个 yield break 语句。
    ///// </summary>
    //public partial class YieldBreakStatement : BreakStatement {

    //    /// <summary>
    //    /// 对当前语句执行语义分析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析状态的上下文对象。</param>
    //    public override void resovle(ResolveContext context) {
    //        //Compiler.notImplement(this);
    //        //context.currentBranching.jumped = true;
    //    }

    //    ///// <summary>
    //    ///// 生成当前节点的代码。
    //    ///// </summary>
    //    ///// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //    //public override void emit(EmitContext context) {
    //    //    Compiler.notImplement(this);
    //    //}

    //}

    ///// <summary>
    ///// 表示一个 yield 语句。
    ///// </summary>
    //public partial class YieldReturnStatement : ReturnStatement {

    //    /// <summary>
    //    /// 对当前语句执行语义分析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析状态的上下文对象。</param>
    //    public override void resovle(ResolveContext context) {
    //        //Compiler.notImplement(this);
    //        //context.currentBranching.jumped = true;
    //    }

    //    ///// <summary>
    //    ///// 生成当前节点的代码。
    //    ///// </summary>
    //    ///// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //    //public override void emit(EmitContext context) {
    //    //    Compiler.notImplement(this);
    //    //}

    //}

    //#endregion

    //#region IterationStatements

    ///// <summary>
    ///// 表示一个 loop 语句。
    ///// </summary>
    //public partial class LoopStatement : Statement {

    //    /// <summary>
    //    /// 对当前语句执行语义分析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析状态的上下文对象。</param>
    //    /// <returns>返回解析后的新语句，它的所有子语句都已经被解析。如果解析出现错误则返回 null 。</returns>
    //    public override void resovle(ResolveContext context) {
    //        // Compiler.notImplement(this);
    //        return;
    //        if (condition != null) {
    //            if ((condition = (StatementExpression)condition.resolveAsValue(context)) == null) {
    //                return;
    //            }

    //            // 转为可用的计数器。
    //            //  Compiler.notImplement(this);
    //            return;
    //        }

    //        context.enterFlowBranching(new ResolveContext.BreakableFlowBranching(context.currentBranching));

    //        // 无限循环不创建子分支，主体代码必然执行。
    //        if (condition != null) {
    //            context.currentBranching.createSibling();
    //        }

    //        context.enterFlowBranching(new ResolveContext.ContinuableFlowBranching(context.currentBranching));

    //        // 执行主体。
    //        body.resovle(context);

    //        context.exitFlowBranching();

    //        // 当前循环导致之后代码无法执行。
    //        context.currentBranching.currentSibling.isJumped = true;

    //        context.exitFlowBranching();

    //    }

    //    ///// <summary>
    //    ///// 生成当前节点的代码。
    //    ///// </summary>
    //    ///// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //    //public override void emit(EmitContext context) {

    //    //    var oldBegin = context.loopBegin;
    //    //    var oldEnd = context.loopEnd;

    //    //    context.loopBegin = context.createLabel();
    //    //    context.loopEnd = context.createLabel();

    //    //    // 无限循环。
    //    //    if (condition == null) {
    //    //        context.markLabel(context.loopBegin);
    //    //        body.emit(context);
    //    //        context.emitBranch(context.loopBegin);
    //    //    } else {

    //    //        // 生成计数器。



    //    //        Compiler.notImplement(this);
    //    //        return;

    //    //        //// 跳到条件。
    //    //        //context.emitBranch(context.loopBegin);

    //    //        //// 主体部分。
    //    //        //var bodyLabel = context.markLabel();
    //    //        //body.emit(context);

    //    //        //// 条件部分。
    //    //        //context.markLabel(context.loopBegin);
    //    //        //condition.emit(context);

    //    //        //// 判断条件然后跳到主体部分。
    //    //        //context.emitBranchIfTrue(bodyLabel);

    //    //    }

    //    //    context.markLabel(context.loopEnd);

    //    //    context.loopBegin = oldBegin;
    //    //    context.loopEnd = oldEnd;

    //    //}

    //}

    ///// <summary>
    ///// 表示一个 for 语句。
    ///// </summary>
    //public partial class ForStatement : Statement {

    //    /// <summary>
    //    /// 对当前语句执行语义分析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析状态的上下文对象。</param>
    //    /// <returns>
    //    /// 返回解析后的新语句，它的所有子语句都已经被解析。如果解析出现错误则返回 null 。
    //    /// </returns>
    //    public override void resovle(ResolveContext context) {

    //        context.enterScope();

    //        // 执行初始化语句。
    //        if (initializer != null) {
    //            //if (initializer is VariableStatement) {
    //            //    for (var variable = ((VariableStatement)initializer).variables; variable != null; variable = variable.next) {
    //            //        context.currentScope.addVariable(variable);
    //            //    }
    //            //}

    //            //initializer.resovle(context);
    //        }

    //        State conditionValue;

    //        bool needToReport = !context.currentBranching.currentSibling.isJumped;

    //        // 执行条件。
    //        if (condition == null) {
    //            conditionValue = State.on;
    //        } else if ((condition = (BooleanExpression)condition.resolveAsValue(context)) == null) {
    //            conditionValue = State.unset;
    //        } else {
    //            conditionValue = condition.resolvedValue;
    //        }

    //        // 进入执行分支。
    //        context.enterFlowBranching(new ResolveContext.BreakableFlowBranching(context.currentBranching));

    //        if (conditionValue == State.on) {
    //            context.currentBranching.currentSibling.isJumped = true;
    //        }
    //        context.currentBranching.createSibling();
    //        if (conditionValue == State.off) {
    //            context.currentBranching.currentSibling.isJumped = true;
    //            if (needToReport && body.reportUnreachableCodeWarning()) {
    //                needToReport = false;
    //            }
    //        }

    //        context.enterFlowBranching(new ResolveContext.ContinuableFlowBranching(context.currentBranching));

    //        // 执行主体。
    //        body.resovle(context);

    //        context.exitFlowBranching();

    //        // 执行迭代器部分。
    //        if (iterator != null) {

    //            if (context.currentBranching.currentSibling.isJumped && needToReport && iterator.reportUnreachableCodeWarning()) {
    //                needToReport = false;
    //            }

    //            iterator.resovle(context);

    //        }

    //        // 当前循环导致之后代码无法执行。
    //        context.currentBranching.currentSibling.isJumped = true;
    //        context.exitFlowBranching();
    //        context.exitScope();
    //    }

    //    ///// <summary>
    //    ///// 生成当前节点的代码。
    //    ///// </summary>
    //    ///// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //    //public override void emit(EmitContext context) {

    //    //    // 执行初始化语句。
    //    //    if (initializer != null) {
    //    //        initializer.emit(context);
    //    //    }

    //    //    var oldBegin = context.loopBegin;
    //    //    var oldEnd = context.loopEnd;

    //    //    context.loopBegin = context.createLabel();
    //    //    context.loopEnd = context.createLabel();

    //    //    // 第一次跳到条件位置。
    //    //    var beginLabel = context.emitBranch();

    //    //    // 生成主体部分。
    //    //    var bodyLabel = context.markLabel();
    //    //    body.emit(context);

    //    //    // 标记循环开始。
    //    //    // continue 之后从这里继续。
    //    //    context.markLabel(context.loopBegin);

    //    //    // 生成迭代器部分。
    //    //    if (iterator != null) {
    //    //        iterator.emit(context);
    //    //    }

    //    //    // 循环的第一次从这里开始。
    //    //    context.markLabel(beginLabel);

    //    //    // 生成条件部分。
    //    //    if (condition == null) {
    //    //        context.emitBranch(bodyLabel);
    //    //    } else {
    //    //        context.markLocation(condition);
    //    //        condition.emit(context);
    //    //        context.emitBranchIfTrue(bodyLabel);
    //    //    }

    //    //    // 标记循环结束。
    //    //    // break 之后从这里继续。
    //    //    context.markLabel(context.loopEnd);

    //    //    context.loopBegin = oldBegin;
    //    //    context.loopEnd = oldEnd;
    //    //}

    //}

    ///// <summary>
    ///// 表示一个 for in 语句。
    ///// </summary>
    //public partial class ForInStatement : Statement {

    //    /// <summary>
    //    /// 对当前语句执行语义分析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析状态的上下文对象。</param>
    //    public override void resovle(ResolveContext context) {
    //        // Compiler.notImplement(this);
    //    }

    //    ///// <summary>
    //    ///// 生成当前节点的代码。
    //    ///// </summary>
    //    ///// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //    //public override void emit(EmitContext context) {
    //    //    Compiler.notImplement(this);
    //    //}

    //}

    ///// <summary>
    ///// 表示一个 for to 语句。
    ///// </summary>
    //public partial class ForToStatement : Statement {

    //    /// <summary>
    //    /// 对当前语句执行语义分析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析状态的上下文对象。</param>
    //    public override void resovle(ResolveContext context) {
    //        //Compiler.notImplement(this);
    //    }

    //    ///// <summary>
    //    ///// 生成当前节点的代码。
    //    ///// </summary>
    //    ///// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //    //public override void emit(EmitContext context) {
    //    //    Compiler.notImplement(this);
    //    //}

    //}

    ///// <summary>
    ///// 表示一个 while 语句。
    ///// </summary>
    //public partial class WhileStatement : Statement {

    //    /// <summary>
    //    /// 对当前语句执行语义分析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析状态的上下文对象。</param>
    //    /// <returns>
    //    /// 返回解析后的新语句，它的所有子语句都已经被解析。如果解析出现错误则返回 null 。
    //    /// </returns>
    //    public override void resovle(ResolveContext context) {

    //        // 执行条件。
    //        if ((condition = (BooleanExpression)condition.resolveAsValue(context)) == null)
    //            return;

    //        // 进入 while break 分支。
    //        context.enterFlowBranching(new ResolveContext.BreakableFlowBranching(context.currentBranching));

    //        // 无限循环不创建子分支，主体代码必然执行。
    //        if (condition.resolvedValue == State.off && !context.currentBranching.currentSibling.isJumped) {
    //            body.reportUnreachableCodeWarning();
    //            context.currentBranching.currentSibling.isJumped = true;
    //        }

    //        // 进入 while continue 分支。
    //        context.enterFlowBranching(new ResolveContext.ContinuableFlowBranching(context.currentBranching));

    //        // 执行主体。
    //        body.resovle(context);

    //        // 退出 while continue 分支。
    //        context.exitFlowBranching();

    //        // 当前循环导致之后代码无法执行。
    //        context.currentBranching.currentSibling.isJumped = true;

    //        // 退出 while break 分支。
    //        // 无限循环主体代码必然执行，否则直接丢弃子分支的信息。
    //        if (condition.resolvedValue != State.on) {
    //            context.exitFlowBranchingWithoutSave();
    //        } else {
    //            context.exitFlowBranching();
    //        }

    //    }

    //    ///// <summary>
    //    ///// 生成当前节点的代码。
    //    ///// </summary>
    //    ///// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //    //public override void emit(EmitContext context) {

    //    //    var oldBegin = context.loopBegin;
    //    //    var oldEnd = context.loopEnd;

    //    //    context.loopBegin = context.createLabel();
    //    //    context.loopEnd = context.createLabel();

    //    //    // 跳到条件。
    //    //    context.emitBranch(context.loopBegin);

    //    //    // 主体部分。
    //    //    var bodyLabel = context.markLabel();
    //    //    body.emit(context);

    //    //    // 条件部分。
    //    //    context.markLabel(context.loopBegin);
    //    //    condition.emit(context);

    //    //    // 判断条件然后跳到主体部分。
    //    //    context.emitBranchIfTrue(bodyLabel);

    //    //    context.markLabel(context.loopEnd);

    //    //    context.loopBegin = oldBegin;
    //    //    context.loopEnd = oldEnd;


    //    //}

    //}

    ///// <summary>
    ///// 表示一个 until 语句。
    ///// </summary>
    //public partial class UntilStatement : Statement {




    //    /// <summary>
    //    /// 对当前语句执行语义分析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析状态的上下文对象。</param>
    //    /// <returns>
    //    /// 返回解析后的新语句，它的所有子语句都已经被解析。如果解析出现错误则返回 null 。
    //    /// </returns>
    //    public override void resovle(ResolveContext context) {
    //        //Compiler.notImplement(this);
    //        //return;
    //        // 执行条件。
    //        if ((condition = (BooleanExpression)condition.resolveAsValue(context)) == null)
    //            return;

    //        // 优化条件是常量的情况。
    //        if (condition.isConstOfTrue) {
    //            body.reportUnreachableCodeWarning();
    //            body = Statement.empty;
    //            return;
    //        }

    //        // 进入 while 分支。
    //        context.enterFlowBranching(new ResolveContext.BreakableFlowBranching(context.currentBranching));

    //        // 无限循环不创建子分支，主体代码必然执行。
    //        if (condition.isConstOfFalse) {
    //            context.currentBranching.createSibling();
    //        }

    //        context.enterFlowBranching(new ResolveContext.ContinuableFlowBranching(context.currentBranching));

    //        // 执行主体。
    //        body.resovle(context);

    //        // 退出 while 分支。
    //        context.exitFlowBranching();

    //        // 当前循环导致之后代码无法执行。
    //        context.currentBranching.currentSibling.isJumped = true;
    //        context.exitFlowBranching();

    //    }

    //    ///// <summary>
    //    ///// 生成当前节点的代码。
    //    ///// </summary>
    //    ///// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //    //public override void emit(EmitContext context) {

    //    //    var oldBegin = context.loopBegin;
    //    //    var oldEnd = context.loopEnd;

    //    //    context.loopBegin = context.createLabel();
    //    //    context.loopEnd = context.createLabel();

    //    //    // 跳到条件。
    //    //    context.emitBranch(context.loopBegin);

    //    //    // 主体部分。
    //    //    var bodyLabel = context.markLabel();
    //    //    body.emit(context);

    //    //    // 条件部分。
    //    //    context.markLabel(context.loopBegin);
    //    //    condition.emit(context);

    //    //    // 判断条件然后跳到主体部分。
    //    //    context.emitBranchIfFalse(bodyLabel);

    //    //    context.markLabel(context.loopEnd);

    //    //    context.loopBegin = oldBegin;
    //    //    context.loopEnd = oldEnd;


    //    //}


    //}

    ///// <summary>
    ///// 表示一个 do while 语句。
    ///// </summary>
    //public partial class DoWhileStatement : Statement {




    //    /// <summary>
    //    /// 对当前语句执行语义分析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析状态的上下文对象。</param>
    //    /// <returns>返回解析后的新语句，它的所有子语句都已经被解析。如果解析出现错误则返回 null 。</returns>
    //    public override void resovle(ResolveContext context) {

    //        // 进入 do 分支。
    //        context.enterFlowBranching(new ResolveContext.BreakableFlowBranching(context.currentBranching));

    //        context.enterFlowBranching(new ResolveContext.ContinuableFlowBranching(context.currentBranching));

    //        bool wasJumped = context.currentBranching.currentSibling.isJumped;

    //        // 执行主体。
    //        body.resovle(context);

    //        context.exitFlowBranching();

    //        // 执行条件。
    //        if (context.currentBranching.currentSibling.isJumped && !wasJumped) {
    //            condition.reportUnreachableCodeWarning();
    //        }

    //        if ((condition = (BooleanExpression)condition.resolveAsValue(context)) != null && condition.resolvedValue == State.on) {
    //            context.currentBranching.currentSibling.isJumped = true;
    //        }

    //        context.exitFlowBranching();

    //    }

    //    ///// <summary>
    //    ///// 生成当前节点的代码。
    //    ///// </summary>
    //    ///// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //    //public override void emit(EmitContext context) {

    //    //    var oldBegin = context.loopBegin;
    //    //    var oldEnd = context.loopEnd;

    //    //    context.loopBegin = context.createLabel();
    //    //    context.loopEnd = context.createLabel();

    //    //    // 执行主体。
    //    //    var bodyLabel = context.markLabel();
    //    //    body.emit(context);

    //    //    // 执行条件。
    //    //    context.markLabel(context.loopBegin);
    //    //    condition.emit(context);

    //    //    // 跳转。
    //    //    context.emitBranchIfTrue(bodyLabel);


    //    //    context.markLabel(context.loopEnd);

    //    //    context.loopBegin = oldBegin;
    //    //    context.loopEnd = oldEnd;
    //    //}


    //}

    ///// <summary>
    ///// 表示一个 do until 语句。
    ///// </summary>
    //public partial class DoUntilStatement : DoWhileStatement {




    //    /// <summary>
    //    /// 对当前语句执行语义分析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析状态的上下文对象。</param>
    //    /// <returns>返回解析后的新语句，它的所有子语句都已经被解析。如果解析出现错误则返回 null 。</returns>
    //    public override void resovle(ResolveContext context) {
    //        //Compiler.notImplement(this);
    //        //return;
    //        // 进入 do 分支。
    //        context.enterFlowBranching(new ResolveContext.BreakableFlowBranching(context.currentBranching));

    //        context.enterFlowBranching(new ResolveContext.ContinuableFlowBranching(context.currentBranching));

    //        // 执行主体。
    //        body.resovle(context);

    //        context.exitFlowBranching();

    //        // 执行条件。
    //        if (context.currentBranching.currentSibling.isJumped) {
    //            condition.reportUnreachableCodeWarning();
    //        } else if ((condition = (BooleanExpression)condition.resolveAsValue(context)) != null && condition.isConstOfFalse) {
    //            context.currentBranching.currentSibling.isJumped = true;
    //        }

    //        context.exitFlowBranching();

    //    }

    //    ///// <summary>
    //    ///// 生成当前节点的代码。
    //    ///// </summary>
    //    ///// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //    //public override void emit(EmitContext context) {

    //    //    var oldBegin = context.loopBegin;
    //    //    var oldEnd = context.loopEnd;

    //    //    context.loopBegin = context.createLabel();
    //    //    context.loopEnd = context.createLabel();

    //    //    // 执行主体。
    //    //    var bodyLabel = context.markLabel();
    //    //    body.emit(context);

    //    //    // 执行条件。
    //    //    context.markLabel(context.loopBegin);

    //    //    condition.emit(context);

    //    //    // 跳转。
    //    //    context.emitBranchIfFalse(bodyLabel);

    //    //    context.markLabel(context.loopEnd);

    //    //    context.loopBegin = oldBegin;
    //    //    context.loopEnd = oldEnd;
    //    //}


    //}

    //public partial class Iterator {
    //    public Block Block;
    //}

    //#endregion

    //#region ExceptionStatements

    ///// <summary>
    ///// 为所有可中断执行的语句提供抽象基类。
    ///// </summary>
    //public abstract partial class ResumableStatement : Statement {
    //}


    ////
    //// Base partial class for blocks using exception handling
    ////
    //public abstract partial class ExceptionStatement : ResumableStatement {
    //    //#if !STATIC
    //    //		bool code_follows;
    //    //#endif
    //    //	protected List<ResumableStatement> resume_points;
    //    //	protected int first_resume_pc;

    //    //	protected ExceptionStatement(Location loc) {
    //    //		this._startLocation = loc;
    //    //	}

    //    //	protected virtual void EmitTryBodyPrepare(EmitContext context) {
    //    //		StateMachineInitializer state_machine = null;
    //    //		if (resume_points != null) {
    //    //			state_machine = (StateMachineInitializer)context.CurrentAnonymousMethod;

    //    //			context.EmitInt((int)IteratorStorey.State.Running);
    //    //			context.Emit(OpCodes.Stloc, state_machine.CurrentPC);
    //    //		}

    //    //		context.BeginExceptionBlock();

    //    //		if (resume_points != null) {
    //    //			context.MarkLabel(resume_point);

    //    //			// For normal control flow, we want to fall-through the Switch
    //    //			// So, we use CurrentPC rather than the $PC field, and initialize it to an outside value above
    //    //			context.Emit(OpCodes.Ldloc, state_machine.CurrentPC);
    //    //			context.EmitInt(first_resume_pc);
    //    //			context.Emit(OpCodes.Sub);

    //    //			Label[] labels = new Label[resume_points.Count];
    //    //			for (int i = 0; i < resume_points.Count; ++i)
    //    //				labels[i] = resume_points[i].PrepareForEmit(context);
    //    //			context.Emit(OpCodes.Switch, labels);
    //    //		}
    //    //	}

    //    //	public void SomeCodeFollows() {
    //    //#if !STATIC
    //    //			code_follows = true;
    //    //#endif
    //    //	}

    //    //	public override bool _resolve(BlockResolveContext context) {
    //    //#if !STATIC
    //    //			// System.Reflection.Emit automatically emits a 'leave' at the end of a try clause
    //    //			// So, ensure there's some IL code after this statement.
    //    //			if (!code_follows && resume_points == null && context.CurrentBranching.CurrentUsageVector.IsUnreachable)
    //    //				context.NeedReturnLabel ();
    //    //#endif
    //    //		return true;
    //    //	}

    //    //	public void AddResumePoint(ResumableStatement stmt, int pc) {
    //    //		if (resume_points == null) {
    //    //			resume_points = new List<ResumableStatement>();
    //    //			first_resume_pc = pc;
    //    //		}

    //    //		if (pc != first_resume_pc + resume_points.Count)
    //    //			throw new InternalErrorException("missed an intervening AddResumePoint?");

    //    //		resume_points.Add(stmt);
    //    //	}

    //}


    ///// <summary>
    ///// 表示一个 try 语句。
    ///// </summary>
    //public partial class TryStatement : ExceptionStatement {




    //    void resovleTryCatchFinally(ResolveContext context) {

    //        context.enterFlowBranching(new ResolveContext.TryCatchFlowBranching(context.currentBranching, this));

    //        tryClause.resovle(context);
    //        context.currentBranching.createSibling();

    //        //catchClause.resovle(context);

    //        //if (catchVariable.type != null) {
    //        //    catchVariable.resolvedType = catchVariable.type.resolveAsType(context.containerMemberDefinition, MemberUsage.variableType);

    //        //    if (catchVariable != null) {
    //        //        //context.currentBlock.
    //        //    }
    //        //}

    //        if (finallyClause != null) {
    //            context.currentBranching.createSibling();
    //            finallyClause.resovle(context);
    //        }

    //        context.exitFlowBranching();
    //    }

    //    /// <summary>
    //    /// 对当前语句执行语义分析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析状态的上下文对象。</param>
    //    /// <returns>
    //    /// 返回解析后的新语句，它的所有子语句都已经被解析。如果解析出现错误则返回 null 。
    //    /// </returns>
    //    public override void resovle(ResolveContext context) {
    //        //if (catchClause != null) {
    //        //    resovleTryCatchFinally(context);
    //        //}
    //    }

    //    ///// <summary>
    //    ///// 生成当前节点的代码。
    //    ///// </summary>
    //    ///// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //    //public override void emit(EmitContext context) {
    //    //    context.beginExceptionBlock();
    //    //    tryClause.emit(context);
    //    //    if (catchClause != null) {
    //    //        context.beginCatchBlock(typeof(Exception));
    //    //        catchClause.emit(context);
    //    //    }

    //    //    if (finallyClause != null) {
    //    //        context.beginFinallyBlock();
    //    //        finallyClause.emit(context);
    //    //        context.endFinally();
    //    //    }


    //    //    context.endExceptionBlock();
    //    //}


    //    ////public Block Block;
    //    ////List<CatchStatement> clauses;
    //    ////readonly bool inside_try_finally;

    //    ////public TryStatement(Block block, List<CatchStatement> catch_clauses, Location l, bool inside_try_finally)
    //    ////	: base(l) {
    //    ////	this.Block = block;
    //    ////	this.clauses = catch_clauses;
    //    ////	this.inside_try_finally = inside_try_finally;
    //    ////}

    //    ////public List<CatchStatement> Clauses {
    //    ////	get {
    //    ////		return clauses;
    //    ////	}
    //    ////}

    //    ////public bool IsTryCatchFinally {
    //    ////	get {
    //    ////		return inside_try_finally;
    //    ////	}
    //    ////}

    //    ////public override bool _resolve(BlockResolveContext context) {

    //    ////}

    //    ////protected override void DoEmit(EmitContext context) {
    //    ////	if (!inside_try_finally)
    //    ////		EmitTryBodyPrepare(context);

    //    ////	Block.Emit(context);

    //    ////	foreach (CatchStatement c in clauses)
    //    ////		c.Emit(context);

    //    ////	if (!inside_try_finally)
    //    ////		context.EndExceptionBlock();
    //    ////}

    //    ////protected override void CloneTo(CloneContext clonectx, Statement t) {
    //    ////	TryStatement target = (TryStatement)t;

    //    ////	target.Block = clonectx.LookupBlock(Block);
    //    ////	if (clauses != null) {
    //    ////		target.clauses = new List<CatchStatement>();
    //    ////		foreach (CatchStatement c in clauses)
    //    ////			target.clauses.Add((CatchStatement)c.Clone(clonectx));
    //    ////	}
    //    ////}

    //    ////public override object Accept(StructuralVisitor visitor) {
    //    ////	return visitor.Visit(this);
    //    ////}
    //}

    ///// <summary>
    ///// 表示一个 throw 语句。
    ///// </summary>
    //public partial class ThrowStatement : Statement {




    //    /// <summary>
    //    /// 对当前语句执行语义分析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析状态的上下文对象。</param>
    //    /// <returns>
    //    /// 返回解析后的新语句，它的所有子语句都已经被解析。如果解析出现错误则返回 null 。
    //    /// </returns>
    //    public override void resovle(ResolveContext context) {
    //        context.currentBranching.currentSibling.isJumped = true;
    //        if (value == null) {
    //            context.currentBranching.execRethrow(this);
    //        }
    //    }

    //    ///// <summary>
    //    ///// 生成当前节点的代码。
    //    ///// </summary>
    //    ///// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //    //public override void emit(EmitContext context) {
    //    //    if (value == null) {
    //    //        context.emitRethrow();
    //    //        return;
    //    //    }

    //    //    value.emit(context);
    //    //    context.emitThrow();
    //    //}


    //}

    //#endregion

    //#endregion

    //#region 成员定义

    //#region MemberDefinition

    ///// <summary>
    ///// 所有成员（如方法、字段、类、模块等）定义的抽象基类。
    ///// </summary>
    //public abstract partial class MemberDefinition : Node {

    //    #region 父级成员

    //    /// <summary>
    //    /// 获取包含当前成员的容器。
    //    /// </summary>
    //    public MemberContainerDefinition parentContainer;

    //    /// <summary>
    //    /// 获取包含当前成员定义的源单元。
    //    /// </summary>
    //    public SourceUnit parentSourceUnit {
    //        get {
    //            var c = this;
    //            do {
    //                SourceUnit p = c as SourceUnit;
    //                if (p != null) {
    //                    return p;
    //                }
    //            } while ((c = c.parentContainer) != null);
    //            return null;
    //        }
    //    }

    //    /// <summary>
    //    /// 获取包含当前成员定义的模块。
    //    /// </summary>
    //    public Package parentPackage {
    //        get {
    //            var c = this;
    //            do {
    //                Package p = c as Package;
    //                if (p != null) {
    //                    return p;
    //                }
    //            } while ((c = c.parentContainer) != null);
    //            return null;
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前成员定义对应的成员引用。
    //    /// </summary>
    //    public MemberReference memberReference;

    //    #endregion

    //    #region 查找成员

    //    /// <summary>
    //    /// 在当前成员上下文中查找指定的名称所代表的实际成员引用。对成员进行模糊匹配。
    //    /// </summary>
    //    /// <param name="memberName">要查找的名称。</param>
    //    /// <param name="alt">返回匹配但有歧义的成员，如果不存在则返回 null。</param>
    //    /// <returns>如果查找成功返回相应的成员引用，否则返回 null。</returns>
    //    public virtual MemberReference findMember(string memberName, ref MemberReference alt) {
    //        // 普通成员不存在子成员，在父容器搜索。
    //        return parentContainer.findMember(memberName, ref alt);
    //    }

    //    /// <summary>
    //    /// 在当前成员上下文中查找指定容器和名称所代表的实际成员引用。对成员进行模糊匹配。
    //    /// </summary>
    //    /// <param name="container">查找所在的容器。</param>
    //    /// <param name="memberName">要查找的名称。</param>
    //    /// <returns>如果查找成功返回相应的成员引用，否则返回 null。</returns>
    //    public MemberReference findMember(MemberContainerReference container, string memberName) {

    //        // 查找当前成员。
    //        var found = container.getMember(memberName);
    //        if (found != null) {
    //            return found;
    //        }

    //        // 查找继承的成员。
    //        var containerType = container as TypeReference;
    //        if (containerType != null) {
    //            return containerType.getMemberFromBase(memberName);
    //        }

    //        return null;
    //    }

    //    /// <summary>
    //    /// 在当前成员上下文中查找指定的名称所代表的实际成员引用。对成员进行精确匹配。
    //    /// </summary>
    //    /// <param name="memberName">要查找的名称。</param>
    //    /// <param name="genericParameterCount">要查找的泛型参数个数。如果不搜索泛型，则传递 0 。</param>
    //    /// <returns>如果查找成功返回相应的成员引用，否则返回 null。</returns>
    //    public virtual MemberReference bindMember(string memberName, int genericParameterCount) {
    //        // 普通成员不存在子成员，在父容器搜索。
    //        return parentContainer.bindMember(memberName, genericParameterCount);
    //    }

    //    /// <summary>
    //    /// 在当前成员上下文中查找指定容器和名称所代表的实际成员引用。对成员进行精确匹配。
    //    /// </summary>
    //    /// <param name="container">查找所在的容器。</param>
    //    /// <param name="memberName">要查找的名称。</param>
    //    /// <param name="genericParameterCount">要查找的泛型参数个数。如果不搜索泛型，则传递 0 。</param>
    //    /// <returns>如果查找成功返回相应的成员引用，否则返回 null。</returns>
    //    public MemberReference bindMember(MemberContainerReference container, string memberName, int genericParameterCount) {

    //        // 查找当前成员。
    //        var found = container.getMember(memberName, genericParameterCount);
    //        if (found != null && ResolveHelper.canAccess(this, found)) {
    //            return found;
    //        }

    //        // 查找继承的成员。
    //        var containerType = container as TypeReference;
    //        if (containerType != null && (found = containerType.getMemberFromBase(memberName, genericParameterCount)) != null && ResolveHelper.canAccess(this, found)) {
    //            return found;
    //        }

    //        return null;
    //    }

    //    /// <summary>
    //    /// 在当前成员上下文中查找指定容器和名称所代表的所有成员引用。
    //    /// </summary>
    //    /// <param name="memberName">要查找的成员名。</param>
    //    /// <param name="genericParameterCount">要查找的泛型参数个数。如果不搜索泛型，则传递 0 。</param>
    //    /// <returns>如果搜索成功返回相应的成员引用，否则返回 null。</returns>
    //    public virtual ISymbol bindExtendedMembers(string memberName, int genericParameterCount) {
    //        // 普通成员不存在子成员，在父容器搜索。
    //        return parentContainer.bindExtendedMembers(memberName, genericParameterCount);
    //    }

    //    /// <summary>
    //    /// 在当前成员上下文中查找指定容器和名称所代表的实际成员引用。
    //    /// </summary>
    //    /// <param name="container">查找所在的容器。</param>
    //    /// <param name="memberName">要查找的名称。</param>
    //    /// <param name="genericParameterCount">要查找的泛型参数个数。如果不搜索泛型，则传递 0 。</param>
    //    /// <returns>如果搜索成功返回相应的成员引用，否则返回 null。</returns>
    //    public ISymbol bindExtendedMembers(MemberContainerReference container, string memberName, int genericParameterCount) {

    //        // 处理类型。
    //        var containerType = container as TypeReference;
    //        if (containerType != null) {

    //            // 查找类型所有成员。
    //            var members = containerType.getExtendedMembers(memberName);

    //            // 成员可能含扩展。
    //            var extensions = containerType.getExtendedExtensionMembers(memberName);
    //            if (extensions != null) {

    //                // 存放成员和扩展集合。
    //                MemberGroupReference result = null;

    //                // 依次处理所有扩展成员。
    //                foreach (var member in extensions) {

    //                    // 如果当前成员定义下指定的扩展被导入。
    //                    if (ResolveHelper.isExtensionEnabled(this, member.parentContainer)) {

    //                        if (result == null) {
    //                            result = new MemberGroupReference();
    //                        }

    //                        // 检测扩展成员是否被覆盖。
    //                        for (int i = 0; i < result.Count; i++) {

    //                            // 如果存在一个指定成员。
    //                            if (result[i].hasSameProperties(member) && ((ExtensionReference)result[i].parentContainer).targetType.isAssignableFrom(((ExtensionReference)member.parentContainer).targetType)) {
    //                                goto end;
    //                            }
    //                        }

    //                        result.Add(member);

    //                    end:
    //                        ;
    //                    }

    //                }

    //                // 成员未找到。
    //                if (result != null) {

    //                    // 添加自身的成员。
    //                    if (members != null) {
    //                        result.AddRange(members);
    //                    }

    //                    return ResolveHelper.filterMembers(result, genericParameterCount);
    //                }

    //            }

    //            return members == null ? null : ResolveHelper.filterMembers(members, genericParameterCount);

    //        }

    //        // 处理其它类型。
    //        var found = container.getMember(memberName, genericParameterCount);
    //        if (found != null && ResolveHelper.canAccess(this, found)) {
    //            return found;
    //        }

    //        return null;
    //    }

    //    #endregion

    //    #region 语义解析

    //    /// <summary>
    //    /// 创建当前成员的引用。在创建引用前无法调用其它解析函数。
    //    /// </summary>
    //    /// <param name="container">要添加到的父容器引用。</param>
    //    public abstract void defineMember(MemberContainerReference container);

    //    /// <summary>
    //    /// 解析当前成员相关的类型引用。在解析类型前无法解析任何主体。
    //    /// </summary>
    //    public abstract void resolveMember();

    //    /// <summary>
    //    /// 解析当前成员定义的主体。
    //    /// </summary>
    //    public abstract void resolveBody();

    //    /// <summary>
    //    /// 标记是否已解析。
    //    /// </summary>
    //    bool _resolved;

    //    /// <summary>
    //    /// 确保当前成员的主体已解析。
    //    /// </summary>
    //    public void resolve() {
    //        if (_resolved) {
    //            return;
    //        }
    //        _resolved = true;
    //        resolveBody();
    //    }

    //    #endregion

    //}

    ///// <summary>
    ///// 表示一个注解。
    ///// </summary>
    //public partial class MemberAnnotation : FuncCallExpression {

    //    /// <summary>
    //    /// 获取或设置目标表达式解析后的类型。
    //    /// </summary>
    //    public TypeReference targetType;

    //    /// <summary>
    //    /// 获取或设置目标表达式解析后的类型。
    //    /// </summary>
    //    public MethodReference targetMember;

    //    /// <summary>
    //    /// 获取或设置解析后的参数值。
    //    /// </summary>
    //    public ResolvedArguments resolvedArguments;

    //}

    //#endregion

    //#region TypeMemberDefinitions

    ///// <summary>
    ///// 表示一个字段定义。
    ///// </summary>
    //public partial class FieldDefinition : MemberDefinition {

    //    /// <summary>
    //    /// 获取当前定义对应的所有字段引用。
    //    /// </summary>
    //    public FieldReference[] fieldReferences;

    //    /// <summary>
    //    /// 创建当前成员的引用。在创建引用前无法调用其它解析函数。
    //    /// </summary>
    //    /// <param name="container">要添加到的父容器引用。</param>
    //    public override void defineMember(MemberContainerReference container) {

    //        // 接口不能定义字段。
    //        if (container.memberType == MemberType.@interface) {
    //            Compiler.error(1, "接口不能包含字段", this.variables.name);
    //            return;
    //        }

    //        // 扩展不能定义字段。
    //        if (container.memberType == MemberType.extension && !container.modifiers.hasFlag(Modifiers.@static)) {
    //            Compiler.error(1, "无法扩展字段，请改用属性", this.variables.name);
    //            return;
    //        }

    //        // 计算变量个数。
    //        int variableCount = 0;
    //        for (var variable = this.variables; variable != null; variable = variable.next) {
    //            variableCount++;
    //        }

    //        this.fieldReferences = new FieldReference[variableCount];

    //        Variable.VariableType variableType = this.modifiers.hasFlag(Modifiers.@const | Modifiers.@static | Modifiers.@volatile) ? (this.modifiers.hasFlag(Modifiers.@static) ? Variable.VariableType.staticLocal : this.modifiers.hasFlag(Modifiers.@const) ? Variable.VariableType.constLocal : Variable.VariableType.volatileLocal) : Variable.VariableType.normalLocal;
    //        bool hasNoAccessibility = this.modifiers.getAccessibility() == Modifiers.none;

    //        variableCount = 0;
    //        for (var variable = variables; variable != null; variable = variable.next) {

    //            variable.variableType = variableType;

    //            this.name = variable.name;

    //            // 如果没有默认修饰符，则清空自动设置的修饰符。
    //            if (hasNoAccessibility) {
    //                this.modifiers &= ~Modifiers.ACCESSIBILITY;
    //            }

    //            if (variableCount == 0) {
    //                ResolveHelper.checkModifiersOfTypeMembers(this, Modifiers.@new | Modifiers.ACCESSIBILITY | Modifiers.@static | Modifiers.final | Modifiers.@const | Modifiers.@volatile);
    //            }

    //            ResolveHelper.setDefaultAccessibility(this);

    //            // 创建成员。
    //            var current = new FieldReference();
    //            current.memberDefinition = this;
    //            current.modifiers = this.modifiers;
    //            current.name = this.nameValue;

    //            // 绑定和添加。
    //            this.memberReference = this.fieldReferences[variableCount++] = current;
    //            ResolveHelper.addMemberReferenceTo(this, container, false);
    //        }
    //    }

    //    /// <summary>
    //    /// 解析当前成员相关的类型引用。在解析类型前无法解析任何主体。
    //    /// </summary>
    //    public override void resolveMember() {

    //        // 解析注解。
    //        ResolveHelper.resolveAnnotations(this);

    //        // 解析返回类型。
    //        var returnType = ResolveHelper.resolveReturnType(this, this.variables.type, MemberUsage.variableType);
    //        int i = 0;
    //        for (var variable = this.variables; variable != null; variable = variable.next) {
    //            this.fieldReferences[i++].returnType = variable.resolvedType = returnType;
    //        }

    //    }

    //    /// <summary>
    //    /// 解析当前成员定义的主体。
    //    /// </summary>
    //    public override void resolveBody() {

    //        // 检查注解类型。
    //        ResolveHelper.checkAnnotations(this);

    //        ResolveHelper.checkConst(modifiers, variables.resolvedType, variables.type);
    //        ResolveHelper.checkVolatile(modifiers, variables.resolvedType, variables.type);
    //        ResolveHelper.checkDeprecated(variables.resolvedType, variables.type);

    //        bool isConst = this.modifiers.hasFlag(Modifiers.@const);
    //        int i = 0;
    //        for (var variable = variables; variable != null; variable = variable.next) {

    //            var fieldReference = this.fieldReferences[i++];
    //            this.name = variable.name;
    //            this.memberReference = fieldReference;

    //            ResolveHelper.checkNew(fieldReference, this.modifiers, variable.name);

    //            if (variable.initialiser != null) {
    //                variable.initialiser = variable.initialiser.resolveAsValue(ResolveHelper.createResolveContext(this), variable.resolvedType);
    //            } else if (isConst) {
    //                Compiler.error(1, "常量字段必须有初始值", variable.name);
    //            }

    //        }

    //    }

    //}

    ///// <summary>
    ///// 表示一个属性定义。
    ///// </summary>
    //public partial class PropertyDefinition : MemberDefinition {

    //    /// <summary>
    //    /// 获取当前成员定义对应的属性引用。
    //    /// </summary>
    //    public PropertyReference propertyReference {
    //        get {
    //            return (PropertyReference)memberReference;
    //        }
    //        set {
    //            memberReference = value;
    //        }
    //    }

    //    public partial class PropertyAccessor : Node {

    //        //#region 生成

    //        ///// <summary>
    //        ///// 生成当前节点的代码。
    //        ///// </summary>
    //        ///// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //        ///// <exception cref="System.NotImplementedException"></exception>
    //        //public override void emit(EmitContext context) {
    //        //    throw new NotImplementedException();
    //        //}

    //        //#endregion

    //    }

    //    /// <summary>
    //    /// 判断当前属性是否需要自动生成主体。
    //    /// </summary>
    //    public bool shouldGenerateBody {
    //        get {
    //            return getAccessor != null && setAccessor != null && getAccessor.body == null && setAccessor.body == null;
    //        }
    //    }

    //    /// <summary>
    //    /// 创建当前成员的引用。在创建引用前无法调用其它解析函数。
    //    /// </summary>
    //    /// <param name="container">要添加到的父容器引用。</param>
    //    public override void defineMember(MemberContainerReference container) {

    //        // 属性禁止全局。
    //        if (container.memberType == MemberType.@namespace) {
    //            Compiler.error(1, "无法在全局范围定义属性", name);
    //            return;
    //        }

    //        // 显式成员不允许有修饰符。
    //        if (explicitType != null && modifiers != Modifiers.none) {
    //            Compiler.error(1, "含有显式接口声明的成员不能有修饰符", name);
    //            return;
    //        }

    //        ResolveHelper.checkModifiersOfTypeMembers(this, Modifiers.ACCESSIBILITY | Modifiers.@new | Modifiers.final | Modifiers.@static | Modifiers.@override | Modifiers.@abstract | Modifiers.@virtual);
    //        ResolveHelper.checkFinal(this);
    //        ResolveHelper.setDefaultAccessibility(this);

    //        // 创建成员。
    //        var current = new PropertyReference();
    //        current.memberDefinition = this;
    //        current.modifiers = this.modifiers;
    //        current.name = this.nameValue;

    //        // 绑定和添加。
    //        memberReference = current;
    //        if (this.explicitType == null) {
    //            ResolveHelper.addMemberReferenceTo(this, container, false);
    //        } else {
    //            ResolveHelper.addMemberReferenceTo(this, container, this.explicitType);
    //        }

    //        ResolveHelper.checkBody(this);
    //    }

    //    /// <summary>
    //    /// 解析当前成员相关的类型引用。在解析类型前无法解析任何主体。
    //    /// </summary>
    //    public override void resolveMember() {

    //        // 解析注解。
    //        ResolveHelper.resolveAnnotations(this);

    //        // 解析返回类型。
    //        propertyReference.returnType = ResolveHelper.resolveReturnType(this, this.returnType, MemberUsage.variableType);

    //        // 解析显式类型声明。
    //        ResolveHelper.resolveExplicitType(this, this.explicitType);

    //    }

    //    /// <summary>
    //    /// 解析当前成员定义的主体。
    //    /// </summary>
    //    public override void resolveBody() {

    //        // 检查注解类型。
    //        ResolveHelper.checkAnnotations(this);

    //        if (explicitType != null) {
    //            // 检查显式类型。
    //            ResolveHelper.checkExplicitType(this, explicitType);
    //        } else {
    //            // 检查覆盖性。
    //            ResolveHelper.checkOverride(this);
    //        }

    //        if (getAccessor != null) {
    //            getAccessor.body.resovle(ResolveHelper.createResolveContext(this));
    //        }

    //        if (setAccessor != null) {
    //            setAccessor.body.resovle(ResolveHelper.createResolveContext(this));
    //        }

    //    }

    //}

    ///// <summary>
    ///// 表示一个索引器定义。
    ///// </summary>
    //public partial class IndexerDefinition : PropertyDefinition {

    //    /// <summary>
    //    /// 获取当前成员定义对应的属性引用。
    //    /// </summary>
    //    public IndexerReference indexerReference {
    //        get {
    //            return (IndexerReference)memberReference;
    //        }
    //        set {
    //            memberReference = value;
    //        }
    //    }

    //    /// <summary>
    //    /// 创建当前成员的引用。在创建引用前无法调用其它解析函数。
    //    /// </summary>
    //    /// <param name="container">要添加到的父容器引用。</param>
    //    public override void defineMember(MemberContainerReference container) {

    //        if (container.memberType == MemberType.@namespace) {
    //            Compiler.error(1, "全局范围无法定义索引器", name);
    //            return;
    //        }

    //        if (container.memberType == MemberType.@class && container.modifiers.hasFlag(Modifiers.@static)) {
    //            Compiler.error(1, "静态类无法定义索引器", name);
    //            return;
    //        }

    //        ResolveHelper.checkModifiersOfTypeMembers(this, Modifiers.ACCESSIBILITY | Modifiers.@new | Modifiers.final | Modifiers.@static | Modifiers.@override | Modifiers.@abstract | Modifiers.@virtual);
    //        ResolveHelper.checkFinal(this);
    //        ResolveHelper.setDefaultAccessibility(this);

    //        // 创建成员。
    //        var current = new IndexerReference();
    //        current.memberDefinition = this;
    //        current.modifiers = modifiers;
    //        current.name = "this[]";

    //        // 绑定和添加。
    //        memberReference = current;
    //        ResolveHelper.addMemberReferenceTo(this, container, false);

    //        ResolveHelper.checkBody(this);
    //    }

    //    /// <summary>
    //    /// 解析当前成员相关的类型引用。在解析类型前无法解析任何主体。
    //    /// </summary>
    //    public override void resolveMember() {

    //        base.resolveMember();

    //        ResolveHelper.checkParameters(this, parameters);

    //    }

    //}

    ///// <summary>
    ///// 表示一个方法定义。
    ///// </summary>
    //public partial class MethodDefinition : MemberDefinition {

    //    /// <summary>
    //    /// 获取当前成员定义对应的方法引用。
    //    /// </summary>
    //    public MethodReference methodReference {
    //        get {
    //            return (MethodReference)memberReference;
    //        }
    //        set {
    //            memberReference = value;
    //        }
    //    }

    //    ///// <summary>
    //    ///// 获取当前方法的泛型参数个数。
    //    ///// </summary>
    //    //public int genericParameterCount {
    //    //    get {
    //    //        var ret = 0;
    //    //        for (var c = genericParameters; c != null; c = c.next)
    //    //            ret++;

    //    //        return ret;
    //    //    }
    //    //}

    //    /// <summary>
    //    /// 在当前成员上下文中查找指定的名称所代表的实际成员引用。对成员进行模糊匹配。
    //    /// </summary>
    //    /// <param name="memberName">要查找的名称。</param>
    //    /// <param name="alt">返回匹配但有歧义的成员，如果不存在则返回 null。</param>
    //    /// <returns>如果查找成功返回相应的成员引用，否则返回 null。</returns>
    //    public override MemberReference findMember(string memberName, ref MemberReference alt) {
    //        return memberReference.getGenericParameter(memberName) ?? parentContainer.findMember(memberName, ref alt);
    //    }

    //    /// <summary>
    //    /// 在当前成员上下文中查找指定的名字所代表的实际成员引用。此函数对成员进行精确匹配。
    //    /// </summary>
    //    /// <param name="memberName">要查找的成员名。</param>
    //    /// <param name="genericParameterCount">要查找的泛型参数个数，如果不搜索泛型，则传递 0 。</param>
    //    /// <returns>如果搜索成功返回相应的成员引用，否则返回 null。</returns>
    //    public override MemberReference bindMember(string memberName, int genericParameterCount) {
    //        if (genericParameterCount == 0) {
    //            var found = memberReference.getGenericParameter(memberName);
    //            if (found != null) {
    //                return found;
    //            }
    //        }
    //        return parentContainer.bindMember(memberName, genericParameterCount);
    //    }

    //    /// <summary>
    //    /// 在当前成员上下文中查找指定容器和名称所代表的所有成员引用。
    //    /// </summary>
    //    /// <param name="memberName">要查找的成员名。</param>
    //    /// <param name="genericParameterCount">要查找的泛型参数个数。如果不搜索泛型，则传递 0 。</param>
    //    /// <returns>如果搜索成功返回相应的成员引用，否则返回 null。</returns>
    //    public override ISymbol bindExtendedMembers(string memberName, int genericParameterCount) {
    //        if (genericParameterCount == 0) {
    //            var found = memberReference.getGenericParameter(memberName);
    //            if (found != null) {
    //                return found;
    //            }
    //        }
    //        return parentContainer.bindExtendedMembers(memberName, genericParameterCount);
    //    }

    //    /// <summary>
    //    /// 创建当前成员的引用。在创建引用前无法调用其它解析函数。
    //    /// </summary>
    //    /// <param name="container">要添加到的父容器引用。</param>
    //    public override void defineMember(MemberContainerReference container) {

    //        // 显示成员不允许有修饰符。
    //        if (explicitType != null && modifiers != Modifiers.none) {
    //            Compiler.error(1, "含有显式接口声明的成员不得有修饰符", name);
    //        }

    //        // 检查修饰符。
    //        ResolveHelper.checkModifiersOfTypeMembers(this, Modifiers.ACCESSIBILITY | Modifiers.@static | Modifiers.@new | Modifiers.@virtual | Modifiers.final | Modifiers.@extern | Modifiers.@abstract | Modifiers.@override);
    //        ResolveHelper.checkFinal(this);
    //        ResolveHelper.setDefaultAccessibility(this);

    //        // 创建引用。
    //        ResolveHelper.defineMethod(this, container);

    //    }

    //    /// <summary>
    //    /// 解析当前成员相关的类型引用。在解析类型前无法解析任何主体。
    //    /// </summary>
    //    public override void resolveMember() {

    //        var methodReference = this.methodReference;

    //        // 解析注解。
    //        ResolveHelper.resolveAnnotations(this);

    //        // 解析返回类型。
    //        if (returnType != null) {
    //            methodReference.returnType = ResolveHelper.resolveReturnType(this, returnType, MemberUsage.type);
    //        } else {
    //            methodReference.returnType = PredefinedTypes.@void;
    //        }

    //        // 解析显示类型声明。
    //        ResolveHelper.resolveExplicitType(this, explicitType);

    //        // 解析泛型参数。
    //        ResolveHelper.resolveGenericParameters(this, genericParameters);

    //        // 解析参数。
    //        methodReference.parameters = ResolveHelper.resolveMethodParameters(this, parameters);

    //        // 检测函数重载是否有效。
    //        for (var m = methodReference.parentContainer.getMember(methodReference.name); m != methodReference; m = m.next) {
    //            if (methodReference.hasSameGenericParameters(m) && ((MethodReference)methodReference).hasSameParamaters((MethodReference)m)) {
    //                Compiler.error(1, String.Format("当前{0}下已存在名为“{1}”且具有相同参数类型的方法定义", parentContainer.memberType.getReadableName(), name.value), name);
    //                break;
    //            }
    //        }

    //    }

    //    /// <summary>
    //    /// 解析当前成员定义的主体。
    //    /// </summary>
    //    public override void resolveBody() {

    //        // 检查注解类型。
    //        ResolveHelper.checkAnnotations(this);

    //        // 扩展的目标成员中不得含相同的成员。
    //        if (explicitType != null) {
    //            // 检查显式类型。
    //            ResolveHelper.checkExplicitType(this, explicitType);
    //        } else {
    //            // 检查覆盖性。
    //            ResolveHelper.checkOverride(this);
    //        }

    //        // 检查泛型参数。
    //        ResolveHelper.checkGenericParameters(this, genericParameters);

    //        // 检查方法参数。
    //        ResolveHelper.checkParameters(this, parameters);

    //        if (body == null) {
    //            return;
    //        }

    //        ResolveContext context = ResolveHelper.createResolveContext(this);
    //        context.returnType = methodReference.returnType;

    //        if (memberReference.isStatic) {
    //            body.parameters = parameters;
    //        } else {
    //            body.parameters = context.createThis(methodReference.returnType);
    //            body.parameters.next = parameters;
    //        }

    //        body.resovle(context);
    //    }

    //    ///// <summary>
    //    ///// 生成当前节点的代码。
    //    ///// </summary>
    //    ///// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //    //public override void emit(EmitContext context) {

    //    //    List<Type> parameters = new List<Type>(4);

    //    //    // 处理参数。
    //    //    for (var parameter = body.parameters; parameter != null; parameter = (Parameter)parameter.next) {
    //    //        parameters.Add(parameter.resolvedType.typeInfo);
    //    //    }

    //    //    var method = context.currentType.DefineMethod(nameValue, System.Reflection.MethodAttributes.Public | System.Reflection.MethodAttributes.Static, typeof(void), parameters.ToArray());

    //    //    for (var parameter = body.parameters; parameter != null; parameter = (Parameter)parameter.next) {
    //    //        method.DefineParameter(parameter.parameterIndex, System.Reflection.ParameterAttributes.In, parameter.name.value);
    //    //    }

    //    //    methodReference.methodInfo = method;

    //    //    if (context.currentAssembly.EntryPoint == null && nameValue == "main") {
    //    //        context.currentAssembly.SetEntryPoint(method);
    //    //    }

    //    //    context.currentGenerator = method.GetILGenerator();
    //    //    System.Diagnostics.SymbolStore.ISymbolDocumentWriter doc = context.currentModule.DefineDocument("sourcefile", Guid.Empty, Guid.Empty, Guid.Empty);
    //    //    context.currentGenerator.MarkSequencePoint(doc, 1, 0, 1, 0);


    //    //    body.emit(context);

    //    //}

    //}

    ///// <summary>
    ///// 表示一个构造函数定义。
    ///// </summary>
    //public partial class ConstructorDefinition : MethodDefinition {

    //    /// <summary>
    //    /// 创建当前成员定义对应的引用。在创建引用前无法使用其它解析函数。
    //    /// </summary>
    //    /// <param name="container">要添加到的容器引用对象。</param>
    //    public override void defineMember(MemberContainerReference container) {

    //        if (container.memberType == MemberType.@namespace) {
    //            Compiler.error(1, "函数缺少返回类型", name);
    //            return;
    //        }

    //        if (container.memberType == MemberType.@interface) {
    //            Compiler.error(1, "接口不允许有构造函数", name);
    //            return;
    //        }

    //        if (container.memberType == MemberType.extension && !container.modifiers.hasFlag(Modifiers.@static)) {
    //            Compiler.error(1, "无法扩展构造函数", name);
    //            return;
    //        }

    //        // 区分静态还是实例构造函数。
    //        if (modifiers.hasFlag(Modifiers.@static)) {
    //            if (modifiers != Modifiers.@static) {
    //                Compiler.error(1, "静态构造函数不允许有除了“static”的其它修饰符", name);
    //                return;
    //            }
    //            if (parameters != null) {
    //                Compiler.error(1, "静态构造函数不允许有参数", name);
    //                return;
    //            }
    //        } else if (container.memberType == MemberType.@struct && parameters == null) {
    //            Compiler.error(1, "结构不允许有空参构造函数", name);
    //            return;
    //        }

    //        ResolveHelper.checkModifiersOfTypeMembers(this, Modifiers.ACCESSIBILITY);
    //        ResolveHelper.setDefaultAccessibility(this, Modifiers.@public);

    //        // 创建引用。
    //        ResolveHelper.defineMethod(this, container);

    //    }

    //    public override void resolveBody() {

    //        // 检查注解类型。
    //        ResolveHelper.checkAnnotations(this);

    //        // 检查方法参数。
    //        ResolveHelper.checkParameters(this, parameters);

    //    }

    //}

    ///// <summary>
    ///// 表示一个构造函数定义。
    ///// </summary>
    //public partial class DeconstructorDefinition : MethodDefinition {

    //    /// <summary>
    //    /// 创建当前成员定义对应的引用。在创建引用前无法使用其它解析函数。
    //    /// </summary>
    //    /// <param name="container">要添加到的容器引用对象。</param>
    //    public override void defineMember(MemberContainerReference container) {

    //        if (container.memberType == MemberType.@namespace) {
    //            Compiler.error(1, "全局范围不允许定义析构函数", name);
    //            return;
    //        }

    //        if (container.memberType == MemberType.@interface) {
    //            Compiler.error(1, "接口不允许有析构函数", name);
    //            return;
    //        }

    //        if (container.memberType == MemberType.extension && !container.modifiers.hasFlag(Modifiers.@static)) {
    //            Compiler.error(1, "无法扩展析构函数", name);
    //            return;
    //        }

    //        if (parameters != null) {
    //            Compiler.error(1, "析构函数不允许有参数", name);
    //            return;
    //        }

    //        // 区分静态还是实例构造函数。
    //        if (modifiers.hasFlag(Modifiers.@static)) {
    //            if (modifiers != Modifiers.@static) {
    //                Compiler.error(1, "静态析构函数不允许有除了“static”的其它修饰符", name);
    //                return;
    //            }
    //        }

    //        ResolveHelper.checkModifiersOfTypeMembers(this, Modifiers.ACCESSIBILITY);
    //        ResolveHelper.setDefaultAccessibility(this, Modifiers.@public);

    //        // 创建引用。
    //        ResolveHelper.defineMethod(this, container);

    //    }

    //}

    ///// <summary>
    ///// 表示操作符重载定义。
    ///// </summary>
    //public partial class OperatorOverloadDefinition : MethodDefinition {

    //    /// <summary>
    //    /// 创建当前成员的引用。在创建引用前无法调用其它解析函数。
    //    /// </summary>
    //    /// <param name="container">要添加到的父容器引用。</param>
    //    public override void defineMember(MemberContainerReference container) {

    //        // 全局成员默认全部静态。
    //        if (container.memberType == MemberType.@namespace) {
    //            Compiler.error(1, "全局范围无法定义操作符重载", name);
    //            return;
    //        }

    //        if (container.modifiers.hasFlag(Modifiers.@static)) {
    //            Compiler.error(1, "静态类无法定义操作符重载", name);
    //            return;
    //        }

    //        // 检查修饰符。
    //        ResolveHelper.checkModifiersOfTypeMembers(this, Modifiers.@public | Modifiers.@static);
    //        ResolveHelper.setDefaultAccessibility(this, Modifiers.@public);

    //        // 创建引用。
    //        ResolveHelper.defineMethod(this, container);

    //    }

    //    ///// <summary>
    //    ///// 检验当前成员的合法性。
    //    ///// </summary>
    //    //public override void checkMember() {

    //    //    // 检查注解类型。
    //    //    checkAnnotations();

    //    //    if (explicitType != null) {
    //    //        // 检查显式类型。
    //    //        checkExplicitType(explicitType);
    //    //    }

    //    //    // 检查方法参数。
    //    //    checkMethodParameter(parameters);

    //    //}

    //}

    ///// <summary>
    ///// 表示一个枚举的成员定义。
    ///// </summary>
    //public partial class EnumFieldDefinition : MemberDefinition {

    //    /// <summary>
    //    /// 获取或设置当前枚举字段的引用。
    //    /// </summary>
    //    public FieldReference fieldReference {
    //        get {
    //            return (FieldReference)memberReference;
    //        }
    //        set {
    //            memberReference = value;
    //        }
    //    }

    //    /// <summary>
    //    /// 创建当前成员的引用。在创建引用前无法调用其它解析函数。
    //    /// </summary>
    //    /// <param name="container">要添加到的父容器引用。</param>
    //    public override void defineMember(MemberContainerReference container) {

    //        // 创建成员。
    //        var current = new FieldReference();
    //        current.memberDefinition = this;
    //        current.modifiers = Modifiers.@public | Modifiers.@const;
    //        current.name = nameValue;

    //        // 绑定和添加。
    //        memberReference = current;
    //        ResolveHelper.addMemberReferenceTo(this, container, false);
    //    }

    //    /// <summary>
    //    /// 解析当前成员相关的类型引用。在解析类型前无法解析任何主体。
    //    /// </summary>
    //    public override void resolveMember() {

    //    }

    //    public ResolveContext createResolveContext() {
    //        return new ResolveContext();
    //    }

    //    /// <summary>
    //    /// 解析当前成员定义的主体。
    //    /// </summary>
    //    public override void resolveBody() {

    //        ResolveHelper.resolveAnnotations(this);

    //        //var parentEnum = enumFieldReference.parentType;

    //        //if (initializer != null) {
    //        //	var context = createResolveContext();
    //        //	if ((initializer = (StatementExpression)initializer.resolveAsValue(context, parentEnum.enumBaseType)) == null) {
    //        //		return;
    //        //	}
    //        //	object value;
    //        //	if (!initializer.tryEval(context, out value)) {
    //        //		Compiler.error(1, "无法在编译时计算枚举字段的值", initializer);
    //        //		return;
    //        //	}

    //        //	enumFieldReference.value = (long)value;

    //        //} else {
    //        //	//enumFieldReference.value = parentEnum.maxValue++;
    //        //}

    //        //bool isValid;

    //        //switch (parentEnum.baseType.primitiveType) {
    //        //	case PrimitiveType.@int:
    //        //		isValid = enumFieldReference.value >= int.MinValue && enumFieldReference.value <= int.MaxValue;
    //        //		break;
    //        //	case PrimitiveType.@byte:
    //        //		isValid = enumFieldReference.value >= byte.MinValue && enumFieldReference.value <= byte.MaxValue;
    //        //		break;
    //        //	case PrimitiveType.@sbyte:
    //        //		isValid = enumFieldReference.value >= sbyte.MinValue && enumFieldReference.value <= sbyte.MaxValue;
    //        //		break;
    //        //	case PrimitiveType.@short:
    //        //		isValid = enumFieldReference.value >= short.MinValue && enumFieldReference.value <= short.MaxValue;
    //        //		break;
    //        //	case PrimitiveType.@ushort:
    //        //		isValid = enumFieldReference.value >= ushort.MinValue && enumFieldReference.value <= ushort.MaxValue;
    //        //		break;
    //        //	case PrimitiveType.@uint:
    //        //		isValid = enumFieldReference.value >= uint.MinValue && enumFieldReference.value <= uint.MaxValue;
    //        //		break;
    //        //	case PrimitiveType.@long:
    //        //		isValid = enumFieldReference.value >= long.MinValue && enumFieldReference.value <= long.MaxValue;
    //        //		break;
    //        //	default:
    //        //		isValid = (ulong)enumFieldReference.value >= ulong.MinValue && (ulong)enumFieldReference.value <= ulong.MaxValue;
    //        //		break;
    //        //}
    //        //if (!isValid) {
    //        //	Compiler.error(1, "数值太大", (Node)initializer ?? name);
    //        //}
    //    }

    //    ///// <summary>
    //    ///// 生成当前节点的代码。
    //    ///// </summary>
    //    ///// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //    ///// <exception cref="System.NotImplementedException"></exception>
    //    //public override void emit(EmitContext context) {
    //    //    throw new NotImplementedException();
    //    //}

    //}

    //#endregion

    //#region MemberContainerDefinition

    ///// <summary>
    ///// 为可以容纳子成员的成员定义提供抽象基类。
    ///// </summary>
    //public abstract partial class MemberContainerDefinition : MemberDefinition {

    //    /// <summary>
    //    /// 获取当前成员定义对应的容器引用。
    //    /// </summary>
    //    public MemberContainerReference memberContainerReference {
    //        get {
    //            return (MemberContainerReference)memberReference;
    //        }
    //        set {
    //            memberReference = value;
    //        }
    //    }

    //    ///// <summary>
    //    ///// 生成当前节点的代码。
    //    ///// </summary>
    //    ///// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //    //public override void emit(EmitContext context) {
    //    //    for (var member = members; member != null; member = member.next) {
    //    //        member.emit(context);
    //    //    }
    //    //}

    //}

    ///// <summary>
    ///// 表示一个命名空间定义。
    ///// </summary>
    //public partial class NamespaceDefinition : MemberContainerDefinition {

    //    /// <summary>
    //    /// 在当前成员上下文中查找指定的名称所代表的实际成员引用。对成员进行模糊匹配。
    //    /// </summary>
    //    /// <param name="memberName">要查找的名称。</param>
    //    /// <param name="alt">返回匹配但有歧义的成员，如果不存在则返回 null。</param>
    //    /// <returns>如果查找成功返回相应的成员引用，否则返回 null。</returns>
    //    public override MemberReference findMember(string memberName, ref MemberReference alt) {
    //        return memberContainerReference.getMember(memberName) ?? parentContainer.findMember(memberName, ref alt);
    //    }

    //    /// <summary>
    //    /// 在当前成员上下文中查找指定的名称所代表的实际成员引用。对成员进行精确匹配。
    //    /// </summary>
    //    /// <param name="memberName">要查找的名称。</param>
    //    /// <param name="genericParameterCount">要查找的泛型参数个数。如果不搜索泛型，则传递 0 。</param>
    //    /// <returns>如果查找成功返回相应的成员引用，否则返回 null。</returns>
    //    public override MemberReference bindMember(string memberName, int genericParameterCount) {
    //        var found = memberContainerReference.getMember(memberName, genericParameterCount);
    //        if (found != null && ResolveHelper.canAccess(this, found)) {
    //            return found;
    //        }
    //        return parentContainer.bindMember(memberName, genericParameterCount);
    //    }

    //    /// <summary>
    //    /// 在当前成员上下文中查找指定容器和名称所代表的所有成员引用。
    //    /// </summary>
    //    /// <param name="memberName">要查找的成员名。</param>
    //    /// <param name="genericParameterCount">要查找的泛型参数个数。如果不搜索泛型，则传递 0 。</param>
    //    /// <returns>如果搜索成功返回相应的成员引用，否则返回 null。</returns>
    //    public override ISymbol bindExtendedMembers(string memberName, int genericParameterCount) {
    //        return bindMember(memberName, genericParameterCount);
    //    }

    //    /// <summary>
    //    /// 创建当前成员的引用。在创建引用前无法调用其它解析函数。
    //    /// </summary>
    //    /// <param name="container">要添加到的父容器引用。</param>
    //    public override void defineMember(MemberContainerReference container) {

    //        if (names != null) {
    //            foreach (var name in names) {
    //                container = defineNamespace(container, name);
    //            }
    //        } else {
    //            container = defineNamespace(container, name);
    //        }

    //        ResolveHelper.defineChildMembers(this, container);
    //    }

    //    private static MemberContainerReference defineNamespace(MemberContainerReference container, Identifier name) {
    //        var exist = container.getMember(name.value);
    //        if (exist == null) {
    //            var current = new NamespaceReference();
    //            current.name = name.value;
    //            container.addMember(current);
    //            return current;
    //        }

    //        if (exist.memberType != MemberType.@namespace) {
    //            Compiler.error(1, String.Format("无法使用“{0}”作为命名空间，因为已经存在同名的{1}定义", container.memberTypeReadableName, name.value), name);
    //        }

    //        return exist as MemberContainerReference ?? container;
    //    }

    //    /// <summary>
    //    /// 解析当前成员相关的类型引用。在解析类型前无法解析任何主体。
    //    /// </summary>
    //    public override void resolveMember() {
    //        ResolveHelper.resolveChildMembers(this);
    //    }

    //    /// <summary>
    //    /// 解析当前成员定义的主体。
    //    /// </summary>
    //    public override void resolveBody() {
    //        ResolveHelper.resolveChildBody(this);
    //    }

    //}

    ///// <summary>
    ///// 表示一个独立的源编译单元。
    ///// </summary>
    //public partial class SourceUnit : MemberContainerDefinition {

    //    /// <summary>
    //    /// 当前容器下所有的导入别名列表。检索名字时将会使用此别名代替实际使用的成员名。
    //    /// </summary>
    //    Dictionary<string, MemberReference> _importAliases;

    //    /// <summary>
    //    /// 获取当前容器下所有的导入的模块列表。检索名字时将会在此列表中指定的容器中查找是否存在匹配项。
    //    /// </summary>
    //    List<MemberContainerReference> _importModules;

    //    /// <summary>
    //    /// 判断当前源码下是否已导入指定的成员。
    //    /// </summary>
    //    /// <param name="member"></param>
    //    /// <returns></returns>
    //    public bool isImported(MemberContainerReference memberContainer) {
    //        if (_importModules != null) {
    //            foreach (var c in _importModules) {
    //                if (c.members.ContainsValue(memberContainer)) {
    //                    return true;
    //                }
    //            }
    //        }

    //        return false;
    //    }

    //    /// <summary>
    //    /// 在当前成员上下文中查找指定的名称所代表的实际成员引用。对成员进行模糊匹配。
    //    /// </summary>
    //    /// <param name="memberName">要查找的名称。</param>
    //    /// <param name="alt">返回匹配但有歧义的成员，如果不存在则返回 null。</param>
    //    /// <returns>如果查找成功返回相应的成员引用，否则返回 null。</returns>
    //    public override MemberReference findMember(string memberName, ref MemberReference alt) {

    //        // 从当前项目直接查找。
    //        var found = parentContainer.findMember(memberName, ref alt);
    //        if (found != null) {
    //            return found;
    //        }

    //        // 在导入模块内查找。
    //        if (_importModules != null) {

    //            // 搜索全部的 import，如果有多个满足条件的类型，则提示错误。
    //            // 如： A 内有 import P; import Q，那么 a 可能是 P 的成员，或者 Q 的成员。
    //            foreach (var c in _importModules) {
    //                var t = c.getMember(memberName);
    //                if (t != null) {
    //                    // 找到 2 个。
    //                    if (found != null) {
    //                        // 两者都可以访问，说明发生了冲突。
    //                        if (ResolveHelper.canAccess(this, t)) {
    //                            if (ResolveHelper.canAccess(this, found)) {
    //                                alt = t;
    //                                break;
    //                            }
    //                        } else {
    //                            continue;
    //                        }
    //                    }
    //                    found = t;
    //                }
    //            }

    //            if (found != null) {
    //                return found;
    //            }
    //        }

    //        // 从当前项目直接查找。
    //        return null;
    //    }

    //    /// <summary>
    //    /// 在当前成员上下文中查找指定的名称所代表的实际成员引用。对成员进行精确匹配。
    //    /// </summary>
    //    /// <param name="memberName">要查找的名称。</param>
    //    /// <param name="genericParameterCount">要查找的泛型参数个数。如果不搜索泛型，则传递 0 。</param>
    //    /// <returns>如果查找成功返回相应的成员引用，否则返回 null。</returns>
    //    public override MemberReference bindMember(string memberName, int genericParameterCount) {

    //        // 从当前项目直接查找。
    //        var found = parentContainer.bindMember(memberName, genericParameterCount);
    //        if (found != null) {
    //            return found;
    //        }

    //        // 在导入别名范围内查找。
    //        if (genericParameterCount == 0 && _importAliases != null && _importAliases.TryGetValue(memberName, out found)) {
    //            return found;
    //        }

    //        // 在导入模块内查找。
    //        if (_importModules != null) {

    //            found = null;

    //            foreach (var c in _importModules) {
    //                MemberReference t = c.getMember(memberName, genericParameterCount);
    //                if (t != null && ResolveHelper.canAccess(this, t)) {
    //                    // 找到两个以上：错误。
    //                    if (found != null) {
    //                        return null;
    //                    }

    //                    found = t;
    //                }
    //            }

    //            if (found != null) {
    //                return found;
    //            }
    //        }

    //        return null;
    //    }

    //    /// <summary>
    //    /// 在当前成员上下文中查找指定容器和名称所代表的所有成员引用。
    //    /// </summary>
    //    /// <param name="memberName">要查找的成员名。</param>
    //    /// <param name="genericParameterCount">要查找的泛型参数个数。如果不搜索泛型，则传递 0 。</param>
    //    /// <returns>如果搜索成功返回相应的成员引用，否则返回 null。</returns>
    //    public override ISymbol bindExtendedMembers(string memberName, int genericParameterCount) {

    //        ISymbol ret = parentContainer.bindExtendedMembers(memberName, genericParameterCount);
    //        if (ret != null) {
    //            return ret;
    //        }

    //        // 在导入别名范围内查找。
    //        MemberReference found;

    //        if (genericParameterCount == 0 && _importAliases != null && _importAliases.TryGetValue(memberName, out found)) {
    //            return found;
    //        }

    //        // 在导入模块内查找。
    //        if (_importModules != null) {

    //            MemberContainerReference container = null;

    //            // 从所有导入成员中查找符合要求的成员集合。
    //            foreach (var c in _importModules) {
    //                for (var member = c.getMember(memberName); member != null; member = member.next) {
    //                    if (member.matchGenericParameters(genericParameterCount) && ResolveHelper.canAccess(this, member)) {

    //                        // 来自两个容器：错误
    //                        if (container != null && container != c) {
    //                            return null;
    //                        }
    //                        container = c;

    //                        // 表示第一个成员。
    //                        if (ret == null) {
    //                            ret = member.memberType != MemberType.method ? member : (ISymbol)new MemberGroupReference() { member };
    //                            continue;
    //                        }

    //                        // 当前成员只能是方法。
    //                        if (member.memberType != MemberType.method) {
    //                            return null;
    //                        }

    //                        if (ret is MemberGroupReference) {
    //                            ((MemberGroupReference)ret).Add(member);
    //                        } else {
    //                            return null;
    //                        }
    //                    }
    //                }
    //            }

    //            if (ret != null) {
    //                return ret;
    //            }
    //        }

    //        return null;
    //    }

    //    /// <summary>
    //    /// 创建当前成员的引用。在创建引用前无法调用其它解析函数。
    //    /// </summary>
    //    /// <param name="container">要添加到的父容器引用。</param>
    //    public override void defineMember(MemberContainerReference container) {

    //        // 绑定和添加。
    //        memberReference = container;

    //        // 定义子成员。
    //        ResolveHelper.defineChildMembers(this, container);
    //    }

    //    /// <summary>
    //    /// 解析当前成员相关的类型引用。在解析类型前无法解析任何主体。
    //    /// </summary>
    //    public override void resolveMember() {

    //        // 解析 imports 。
    //        for (var importDirective = imports; importDirective != null; importDirective = importDirective.next) {

    //            // 解析表达式对应的实际类型。
    //            var importTargetMember = importDirective.value.resolveAsMember(parentContainer, MemberUsage.importTarget);
    //            if (importTargetMember == null) {
    //                continue;
    //            }

    //            // import module;
    //            if (importDirective.alias == null) {

    //                // 作进一步过滤。
    //                switch (importTargetMember.memberType) {
    //                    case MemberType.@namespace:
    //                    case MemberType.@enum:
    //                        break;
    //                    case MemberType.@class:
    //                        if (importTargetMember.modifiers.hasFlag(Modifiers.@static))
    //                            break;
    //                        Compiler.error(1, String.Format("import 指令只能只导入模块、枚举和静态类（“{0}”不是静态类）", importTargetMember.fullName), this);
    //                        continue;
    //                    default:
    //                        Compiler.error(1, String.Format("import 指令只能只导入模块、枚举和静态类（“{0}”是{1}）", importTargetMember.fullName, importTargetMember.memberTypeReadableName), this);
    //                        continue;
    //                }

    //                var importTargetMemberContainer = (MemberContainerReference)importTargetMember;

    //                if (_importModules == null) {
    //                    _importModules = new List<MemberContainerReference>();
    //                }
    //                if (_importModules.IndexOf(importTargetMemberContainer) >= 0) {
    //                    Compiler.warning(0, String.Format("当前上下文已声明导入“{0}”", importTargetMemberContainer.fullName), importDirective.value);
    //                    continue;
    //                }
    //                _importModules.Add(importTargetMemberContainer);
    //                continue;
    //            }

    //            // import alias;

    //            #region 检查 import 别名是否合法

    //            // 只能为类型取别名
    //            if (!(importTargetMember is TypeReference)) {
    //                Compiler.error(1, String.Format("只能为类型取别名(“{0}”是{1})", importTargetMember.fullName, importTargetMember.memberType.getReadableName()), importDirective.value);
    //                continue;
    //            }

    //            // 检查是否有重复的别名。
    //            if (_importAliases != null && _importAliases.ContainsKey(importDirective.alias.value)) {
    //                Compiler.error(1, String.Format("当前上下文已存在别名“{0}”", importDirective.alias.value), importDirective.alias);
    //                continue;
    //            }

    //            // 检查别名是否和成员名冲突。
    //            if (memberContainerReference.getMember(importDirective.alias.value, 0) != null) {
    //                Compiler.error(0, String.Format("当前上下文已经存在名为“{0}”的成员定义", importDirective.alias.value), importDirective.alias);
    //                continue;
    //            }

    //            #endregion

    //            if (_importAliases == null) {
    //                _importAliases = new Dictionary<string, MemberReference>();
    //            }

    //            _importAliases.Add(importDirective.alias.value, importTargetMember);

    //        }

    //        ResolveHelper.resolveChildMembers(this);
    //    }

    //    /// <summary>
    //    /// 解析当前成员定义的主体。
    //    /// </summary>
    //    public override void resolveBody() {
    //        ResolveHelper.resolveChildBody(this);
    //    }

    //}

    ///// <summary>
    ///// 表示一个 import 指令。
    ///// </summary>
    //public partial class ImportDirective : Node {

    //}

    ///// <summary>
    ///// 表示一个独立的包。
    ///// </summary>
    ///// <remarks>
    ///// 包是所有成员的顶层容器对象。
    ///// </remarks>
    //public partial class Package : MemberContainerDefinition {

    //    /// <summary>
    //    /// 初始化 <see cref="Package"/> 类的新实例。
    //    /// </summary>
    //    public Package() {
    //        memberReference = new PackageReference();
    //    }

    //    /// <summary>
    //    /// 在当前成员上下文中查找指定的名称所代表的实际成员引用。对成员进行模糊匹配。
    //    /// </summary>
    //    /// <param name="memberName">要查找的名称。</param>
    //    /// <param name="alt">返回匹配但有歧义的成员，如果不存在则返回 null。</param>
    //    /// <returns>如果查找成功返回相应的成员引用，否则返回 null。</returns>
    //    public override MemberReference findMember(string memberName, ref MemberReference alt) {

    //        // 在全局容器下查找。查找当前项目定义的成员以及导入的成员。
    //        return memberContainerReference.getMember(memberName);
    //    }

    //    /// <summary>
    //    /// 在当前成员上下文中查找指定的名称所代表的实际成员引用。对成员进行精确匹配。
    //    /// </summary>
    //    /// <param name="memberName">要查找的名称。</param>
    //    /// <param name="genericParameterCount">要查找的泛型参数个数。如果不搜索泛型，则传递 0 。</param>
    //    /// <returns>如果查找成功返回相应的成员引用，否则返回 null。</returns>
    //    public override MemberReference bindMember(string memberName, int genericParameterCount) {

    //        // 在全局容器下查找。查找当前项目定义的成员以及导入的成员。
    //        var found = memberContainerReference.getMember(memberName, genericParameterCount);
    //        if (found != null && ResolveHelper.canAccess(this, found)) {
    //            return found;
    //        }
    //        return null;
    //    }

    //    /// <summary>
    //    /// 在当前成员上下文中查找指定容器和名称所代表的所有成员引用。
    //    /// </summary>
    //    /// <param name="memberName">要查找的成员名。</param>
    //    /// <param name="genericParameterCount">要查找的泛型参数个数。如果不搜索泛型，则传递 0 。</param>
    //    /// <returns>如果搜索成功返回相应的成员引用，否则返回 null。</returns>
    //    public override ISymbol bindExtendedMembers(string memberName, int genericParameterCount) {
    //        return bindMember(memberName, genericParameterCount);
    //    }

    //    /// <summary>
    //    /// 创建当前成员的引用。在创建引用前无法调用其它解析函数。
    //    /// </summary>
    //    /// <param name="container">要添加到的父容器引用。</param>
    //    public override void defineMember(MemberContainerReference container) {
    //        ResolveHelper.defineChildMembers(this, container);
    //    }

    //    /// <summary>
    //    /// 解析当前成员相关的类型引用。在解析类型前无法解析任何主体。
    //    /// </summary>
    //    public override void resolveMember() {
    //        ResolveHelper.resolveChildMembers(this);
    //    }

    //    /// <summary>
    //    /// 解析当前成员定义的主体。
    //    /// </summary>
    //    public override void resolveBody() {
    //        ResolveHelper.resolveChildBody(this);
    //    }

    //    /// <summary>
    //    /// 生成整个模块的代码。
    //    /// </summary>
    //    /// <returns>如果成功则返回 true， 否则返回 false。</returns>
    //    public bool emit() {
    //        //EmitContext context = new EmitContext(nameValue);
    //        //base.emit(context);
    //        //context.setEntryPoint(null);
    //        //context.save();
    //        return Compiler.errorCount == 0;
    //    }

    //    /// <summary>
    //    /// 对当前模块定义进行语义分析。
    //    /// </summary>
    //    /// <returns>如果成功则返回 true， 否则返回 false。</returns>
    //    public new void resolve() {

    //        // 1. 定义所有成员。
    //        defineMember(memberContainerReference);

    //        if (Compiler.errorCount > 0) {
    //            return;
    //        }

    //        // 导入系统成员。
    //        if (Compiler.options.isCompilingSystemLib) {
    //            PredefinedTypes.init(this);
    //        }

    //        // 2. 解析成员本身。
    //        resolveMember();

    //        if (Compiler.errorCount > 0) {
    //            return;
    //        }

    //        // 3. 解析成员主体。
    //        base.resolve();

    //    }

    //}

    ///// <summary>
    ///// 表示一个扩展定义。
    ///// </summary>
    //public partial class ExtensionDefinition : MemberContainerDefinition {

    //    public ExtensionReference extensionReference {
    //        get {
    //            return (ExtensionReference)memberReference;
    //        }
    //        set {
    //            memberReference = value;
    //        }
    //    }

    //    /// <summary>
    //    /// 创建当前成员的引用。在创建引用前无法调用其它解析函数。
    //    /// </summary>
    //    /// <param name="parentContainer">要添加到的父容器引用。</param>
    //    public override void defineMember(MemberContainerReference parentContainer) {

    //        //if (parentContainer.isGeneric) {
    //        //	Compiler.error(1, "无法在泛型类内部定义扩展", name);
    //        //	return;
    //        //}

    //        // 检查修饰符。
    //        ResolveHelper.setDefaultAccessibility(this);
    //        ResolveHelper.checkModifiersOfTypes(this, Modifiers.ACCESSIBILITY);

    //        // 创建成员。
    //        var current = new ExtensionReference();
    //        current.memberDefinition = this;
    //        current.modifiers = modifiers;
    //        current.name = "@extension";

    //        // 绑定和添加。
    //        memberReference = current;
    //        parentContainer.addMember(memberReference);

    //        // 定义子成员。
    //        ResolveHelper.defineChildMembers(this, current);

    //    }

    //    /// <summary>
    //    /// 解析当前成员相关的类型引用。在解析类型前无法解析任何主体。
    //    /// </summary>
    //    public override void resolveMember() {
    //        var type = extensionReference.targetType = targetType.resolveAsType(this, MemberUsage.type);
    //        type.addExtension(extensionReference);
    //        ResolveHelper.resolveChildMembers(this);
    //    }

    //    public override void resolveBody() {

    //    }


    //}

    ///// <summary>
    ///// 表示一个枚举定义。
    ///// </summary>
    //public partial class EnumDefinition : MemberContainerDefinition {

    //    /// <summary>
    //    /// 获取当前成员定义对应的类型引用。
    //    /// </summary>
    //    public TypeReference typeReference {
    //        get {
    //            return (TypeReference)memberReference;
    //        }
    //        set {
    //            memberReference = value;
    //        }
    //    }

    //    /// <summary>
    //    /// 在当前成员上下文中查找指定的名称所代表的实际成员引用。对成员进行模糊匹配。
    //    /// </summary>
    //    /// <param name="memberName">要查找的名称。</param>
    //    /// <param name="alt">返回匹配但有歧义的成员，如果不存在则返回 null。</param>
    //    /// <returns>如果查找成功返回相应的成员引用，否则返回 null。</returns>
    //    public override MemberReference findMember(string memberName, ref MemberReference alt) {
    //        return memberContainerReference.getMember(memberName) ?? parentContainer.findMember(memberName, ref alt);
    //    }

    //    /// <summary>
    //    /// 在当前成员上下文中查找指定的名称所代表的实际成员引用。对成员进行精确匹配。
    //    /// </summary>
    //    /// <param name="memberName">要查找的名称。</param>
    //    /// <param name="genericParameterCount">要查找的泛型参数个数。如果不搜索泛型，则传递 0 。</param>
    //    /// <returns>如果查找成功返回相应的成员引用，否则返回 null。</returns>
    //    public override MemberReference bindMember(string memberName, int genericParameterCount) {

    //        // 搜索枚举成员。
    //        if (genericParameterCount == 0) {
    //            var found = memberContainerReference.getMember(memberName);
    //            if (found != null) {
    //                return found;
    //            }
    //        }

    //        // 找不到则在上级继续查找。
    //        return parentContainer.bindMember(memberName, genericParameterCount);

    //    }

    //    /// <summary>
    //    /// 在当前成员上下文中查找指定容器和名称所代表的所有成员引用。
    //    /// </summary>
    //    /// <param name="memberName">要查找的成员名。</param>
    //    /// <param name="genericParameterCount">要查找的泛型参数个数。如果不搜索泛型，则传递 0 。</param>
    //    /// <returns>如果搜索成功返回相应的成员引用，否则返回 null。</returns>
    //    public override ISymbol bindExtendedMembers(string memberName, int genericParameterCount) {
    //        if (genericParameterCount == 0) {
    //            var found = memberContainerReference.getMember(memberName);
    //            if (found != null) {
    //                return found;
    //            }
    //        }
    //        return parentContainer.bindExtendedMembers(memberName, genericParameterCount);
    //    }

    //    /// <summary>
    //    /// 创建当前成员的引用。在创建引用前无法调用其它解析函数。
    //    /// </summary>
    //    /// <param name="parentContainer">要添加到的父容器引用。</param>
    //    public override void defineMember(MemberContainerReference parentContainer) {

    //        // 检查修饰符。
    //        ResolveHelper.checkModifiersOfTypes(this, Modifiers.ACCESSIBILITY | Modifiers.@new);
    //        ResolveHelper.setDefaultAccessibility(this);

    //        // 创建成员。
    //        var current = new TypeReference(MemberType.@enum);
    //        current.memberDefinition = this;
    //        current.modifiers = modifiers;
    //        current.name = nameValue;

    //        // 绑定和添加。
    //        memberReference = current;
    //        ResolveHelper.addMemberReferenceTo(this, current, false);

    //        // 定义子成员。
    //        ResolveHelper.defineChildMembers(this, parentContainer);
    //    }

    //    /// <summary>
    //    /// 解析当前成员相关的类型引用。在解析类型前无法解析任何主体。
    //    /// </summary>
    //    public override void resolveMember() {

    //        // 解析基类型。
    //        TypeReference enumBaseType;
    //        if (baseType != null) {
    //            enumBaseType = baseType.resolveAsType(this, MemberUsage.variableType);
    //            if (enumBaseType == null) {
    //                return;
    //            }
    //        } else {
    //            enumBaseType = PredefinedTypes.@int;
    //        }

    //        typeReference.baseType = ((GenericTypeDefinitionReference)PredefinedTypes.@enum).makeGenericType(enumBaseType);

    //        // 解析子成员。
    //        ResolveHelper.resolveChildMembers(this);
    //    }

    //    public override void resolveBody() {

    //        // 解析注解。
    //        ResolveHelper.checkAnnotations(this);

    //        // 解析 new 关键字。
    //        ResolveHelper.checkNew(this);

    //        // 检查子成员。

    //        ResolveHelper.resolveChildBody(this);
    //    }


    //    ///// <summary>
    //    ///// 生成当前节点的代码。
    //    ///// </summary>
    //    ///// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //    //public override void emit(EmitContext context) {

    //    //    var prevType = context.currentType;

    //    //    context.currentType = context.currentType.DefineNestedType(name.value, System.Reflection.TypeAttributes.NestedPublic, typeof(Enum));

    //    //    base.emit(context);

    //    //    context.currentType.CreateType();

    //    //    context.currentType = prevType;
    //    //}

    //}

    //#endregion

    //#region TypeDefinitions

    ///// <summary>
    ///// 所有类型（类、结构、接口）定义的抽象基类。
    ///// </summary>
    //public abstract partial class TypeDefinition : MemberContainerDefinition {

    //    /// <summary>
    //    /// 获取当前成员定义对应的类型引用。
    //    /// </summary>
    //    public TypeReference typeReference {
    //        get {
    //            return (TypeReference)memberReference;
    //        }
    //        set {
    //            memberReference = value;
    //        }
    //    }

    //    /////// <summary>
    //    /////// 获取当前类型的泛型形参个数。
    //    /////// </summary>
    //    ////public int genericParameterCount {
    //    ////	get {
    //    ////		var ret = 0;
    //    ////		for (var genericParameter = genericParameters; genericParameter != null; genericParameter = genericParameter.next)
    //    ////			ret++;
    //    ////		return ret;
    //    ////	}
    //    ////}

    //    /// <summary>
    //    /// 在当前成员上下文中查找指定的名称所代表的实际成员引用。对成员进行模糊匹配。
    //    /// </summary>
    //    /// <param name="memberName">要查找的名称。</param>
    //    /// <param name="alt">返回匹配但有歧义的成员，如果不存在则返回 null。</param>
    //    /// <returns>如果查找成功返回相应的成员引用，否则返回 null。</returns>
    //    public override MemberReference findMember(string memberName, ref MemberReference alt) {
    //        var typeReference = this.typeReference;

    //        // 依次查找。
    //        return typeReference.getMember(memberName) ?? typeReference.getGenericParameter(memberName) ?? typeReference.getMemberFromBase(memberName) ?? parentContainer.findMember(memberName, ref alt);
    //    }

    //    /// <summary>
    //    /// 在当前成员上下文中查找指定的名称所代表的实际成员引用。对成员进行精确匹配。
    //    /// </summary>
    //    /// <param name="memberName">要查找的名称。</param>
    //    /// <param name="genericParameterCount">要查找的泛型参数个数。如果不搜索泛型，则传递 0 。</param>
    //    /// <returns>如果查找成功返回相应的成员引用，否则返回 null。</returns>
    //    public override MemberReference bindMember(string memberName, int genericParameterCount) {

    //        var typeReference = this.typeReference;

    //        // 从当前类直接查找。同个类不需要判断访问性即可直接访问。
    //        var found = typeReference.getMember(memberName, genericParameterCount);
    //        if (found != null) {
    //            return found;
    //        }

    //        // 查找泛型参数。泛型参数本身不能和泛型参数同时使用。
    //        if (genericParameterCount == 0 && (found = typeReference.getGenericParameter(memberName)) != null) {
    //            return found;
    //        }

    //        // 查找继承的成员。
    //        if ((found = typeReference.getMemberFromBase(memberName, genericParameterCount)) != null && ResolveHelper.canAccess(this, found)) {
    //            return found;
    //        }

    //        // 找不到则在上级继续查找。
    //        return parentContainer.bindMember(memberName, genericParameterCount);
    //    }

    //    /// <summary>
    //    /// 在当前成员上下文中查找指定容器和名称所代表的所有成员引用。
    //    /// </summary>
    //    /// <param name="memberName">要查找的成员名。</param>
    //    /// <param name="genericParameterCount">要查找的泛型参数个数。如果不搜索泛型，则传递 0 。</param>
    //    /// <returns>如果搜索成功返回相应的成员引用，否则返回 null。</returns>
    //    public override ISymbol bindExtendedMembers(string memberName, int genericParameterCount) {

    //        var typeReference = this.typeReference;

    //        // 查找泛型参数。泛型参数本身不能和泛型参数同时使用。
    //        if (genericParameterCount == 0) {
    //            var found = typeReference.getGenericParameter(memberName);
    //            if (found != null) {
    //                return found;
    //            }
    //        }

    //        // 查找展开的成员列表。
    //        var members = typeReference.getExtendedMembers(memberName);
    //        if (members != null) {
    //            var found = ResolveHelper.filterMembers(members, genericParameterCount);
    //            if (found != null) {
    //                return found;
    //            }
    //        }

    //        return parentContainer.bindExtendedMembers(memberName, genericParameterCount);
    //    }

    //    //    /// <summary>
    //    //    /// 生成当前节点的代码。
    //    //    /// </summary>
    //    //    /// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //    //    public override void emit(EmitContext context) {
    //    //        context.type = context.module.DefineType(nameString, System.Reflection.TypeAttributes.Public, typeof(object));
    //    //        base.emit(context);
    //    //        context.type.CreateType();
    //    //    }

    //}

    ///// <summary>
    ///// 表示一个类定义。
    ///// </summary>
    //public partial class ClassDefinition : TypeDefinition {

    //    /// <summary>
    //    /// 创建当前成员的引用。在创建引用前无法调用其它解析函数。
    //    /// </summary>
    //    /// <param name="container">要添加到的父容器引用。</param>
    //    public override void defineMember(MemberContainerReference container) {

    //        // 检查修饰符。
    //        ResolveHelper.checkModifiersOfTypes(this, Modifiers.ACCESSIBILITY | Modifiers.@new | Modifiers.final | Modifiers.@abstract | Modifiers.@static);
    //        ResolveHelper.setDefaultAccessibility(this);

    //        // 创建类型。
    //        ResolveHelper.defineType(this, container);
    //    }

    //    /// <summary>
    //    /// 解析当前成员相关的类型引用。在解析类型前无法解析任何主体。
    //    /// </summary>
    //    public override void resolveMember() {

    //        // 解析注解。
    //        ResolveHelper.resolveAnnotations(this);

    //        // 解析泛型参数。
    //        ResolveHelper.resolveGenericParameters(this, genericParameters);

    //        // 解析基类。
    //        resolveBaseTypes();

    //        // 解析子类型。
    //        ResolveHelper.resolveChildMembers(this);
    //    }

    //    Expression _baseTypeNode;

    //    private void resolveBaseTypes() {

    //        var typeReference = this.typeReference;

    //        // 用户未定义基类，则默认继承 Object 。
    //        if (this.baseTypes == null) {
    //            typeReference.baseType = PredefinedTypes.@object;
    //            return;
    //        }

    //        // 静态类不允许继承。
    //        if (modifiers.hasFlag(Modifiers.@static)) {
    //            Compiler.error(1, "静态类不允许继承", this.baseTypes[0]);
    //        }

    //        // 解析继承列表。
    //        foreach (var baseTypeExpr in this.baseTypes) {
    //            var resolvedBaseType = baseTypeExpr.resolveAsType(this.parentContainer, MemberUsage.type);
    //            if (resolvedBaseType == null) {
    //                continue;
    //            }

    //            switch (resolvedBaseType.memberType) {
    //                case MemberType.@class:
    //                    if (resolvedBaseType.modifiers.hasFlag(Modifiers.final)) {
    //                        Compiler.error(1, String.Format("无法从最终类“{0}”继承", resolvedBaseType.signature), baseTypeExpr);
    //                        continue;
    //                    }

    //                    if (resolvedBaseType.modifiers.hasFlag(Modifiers.@static)) {
    //                        Compiler.error(1, String.Format("无法从静态类“{0}”继承", resolvedBaseType.signature), baseTypeExpr);
    //                        continue;
    //                    }

    //                    if (typeReference.implementedTypes != null) {
    //                        Compiler.error(1, String.Format("基类“{0}”必须出现在所有接口之前", resolvedBaseType.signature), baseTypeExpr);
    //                        continue;
    //                    }

    //                    if (this._baseTypeNode != null) {
    //                        if (typeReference.baseType == resolvedBaseType) {
    //                            Compiler.error(1, String.Format("当前类型已经声明了继承“{0}”", resolvedBaseType.signature), baseTypeExpr);
    //                        } else {
    //                            Compiler.error(1, String.Format("“{0}”不能同时继承“{1}”和“{2}”", typeReference.signature, typeReference.baseType.signature, resolvedBaseType.signature), baseTypeExpr);
    //                        }
    //                        continue;
    //                    }

    //                    this._baseTypeNode = baseTypeExpr;
    //                    typeReference.baseType = resolvedBaseType;
    //                    break;
    //                case MemberType.@interface:
    //                    if (!typeReference.addInterface(resolvedBaseType)) {
    //                        Compiler.error(1, String.Format("“{0}”已经包含在继承列表中", resolvedBaseType.signature), baseTypeExpr);
    //                    }
    //                    break;
    //                case MemberType.@void:
    //                    _baseTypeNode = baseTypeExpr;
    //                    typeReference.baseType = null;
    //                    return;
    //                default:
    //                    Compiler.error(1, String.Format("无法从{1}“{0}”继承", resolvedBaseType.signature, resolvedBaseType.memberTypeReadableName), baseTypeExpr);
    //                    break;
    //            }
    //        }

    //        var baseType = typeReference.baseType;
    //        if (baseType == null) {
    //            typeReference.baseType = PredefinedTypes.@object;
    //            return;
    //        }

    //        #region 检查循环继承关系

    //        // 无法从内嵌类型继承。
    //        if (baseType.isNestedChildOf(typeReference)) {
    //            Compiler.error(1, String.Format("无法从内嵌{1}“{0}”继承", baseType.signature, baseType.memberTypeReadableName), _baseTypeNode);
    //            return;
    //        }

    //        // 不是当前项目内定义的类不存在循环继承的关系。
    //        // 如果父类的父类还未解析完成，则不继续判断，等待解析父类时进行判断。
    //        while (baseType != null && baseType.memberDefinition != null) {
    //            if (baseType == typeReference) {
    //                Compiler.error(1, String.Format("检测到“{0}”和“{1}”有循环继承关系", typeReference.baseType.signature, typeReference.signature), _baseTypeNode);

    //                // 删除循环引用，防止其它地方无法处理基类。
    //                typeReference.baseType = null;
    //                return;
    //            }
    //            baseType = baseType.baseType;
    //        }

    //        #endregion

    //    }

    //    /// <summary>
    //    /// 解析当前成员定义的主体。
    //    /// </summary>
    //    public override void resolveBody() {

    //        // 检查注解类型。
    //        ResolveHelper.checkAnnotations(this);

    //        // 解析 new 关键字。
    //        ResolveHelper.checkNew(this);

    //        // 解析泛型参数。
    //        ResolveHelper.checkGenericParameters(this, genericParameters);

    //        // 解析继承列表。
    //        if (baseTypes != null) {

    //            // 继承的基类。
    //            if (_baseTypeNode != null) {

    //                var typeReference = this.typeReference;

    //                // 继承类型必须达到当前类型的访问性。
    //                if (!typeReference.baseType.isAccessibleAs(typeReference)) {
    //                    Compiler.error(1, String.Format("基类类型“{0}”的访问权限不能低于“{1}”", typeReference.baseType.signature, memberReference.signature), _baseTypeNode);
    //                    return;
    //                }

    //                // 检查成员是否被否定。
    //                ResolveHelper.checkDeprecated(typeReference.baseType, _baseTypeNode);

    //                // 检查当前类是否已经实现了抽象类全部成员。
    //                if (!typeReference.modifiers.hasFlag(Modifiers.@abstract)) {
    //                    var absractMembers = typeReference.baseType.getExtendedAbstractMembers();
    //                    if (absractMembers != null) {
    //                        foreach (var member in absractMembers) {
    //                            if (typeReference.getSameMember(member) == member) {
    //                                Compiler.error(1, String.Format("“{0}”未实现抽象的成员“{1}”", typeReference.signature, member.signature), name);
    //                            }
    //                        }
    //                    }
    //                }

    //            }

    //            // 继承的接口。
    //            ResolveHelper.checkInterfaces(this, _baseTypeNode != null);

    //        }

    //        ResolveHelper.resolveChildBody(this);

    //        checkPrivateFields();
    //    }

    //    /// <summary>
    //    /// 提示私有字段从未赋值。
    //    /// </summary>
    //    private void checkPrivateFields() {

    //    }


    //    ///// <summary>
    //    ///// 生成当前节点的代码。
    //    ///// </summary>
    //    ///// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //    //public override void emit(EmitContext context) {

    //    //    var prevType = context.currentType;

    //    //    context.currentType = context.currentType.DefineNestedType(nameValue);

    //    //    base.emit(context);

    //    //    context.currentType.CreateType();

    //    //    context.currentType = prevType;
    //    //}


    //}

    ///// <summary>
    ///// 表示一个结构定义。
    ///// </summary>
    //public partial class StructDefinition : TypeDefinition {

    //    /// <summary>
    //    /// 创建当前成员的引用。在创建引用前无法调用其它解析函数。
    //    /// </summary>
    //    /// <param name="container">要添加到的父容器引用。</param>
    //    public override void defineMember(MemberContainerReference container) {

    //        // 检查修饰符。
    //        ResolveHelper.checkModifiersOfTypes(this, Modifiers.ACCESSIBILITY | Modifiers.@new);
    //        ResolveHelper.setDefaultAccessibility(this);

    //        // 创建类型。
    //        ResolveHelper.defineType(this, container);
    //    }

    //    /// <summary>
    //    /// 解析当前成员相关的类型引用。在解析类型前无法解析任何主体。
    //    /// </summary>
    //    public override void resolveMember() {

    //        // 解析注解。
    //        ResolveHelper.resolveAnnotations(this);

    //        // 解析泛型参数。
    //        ResolveHelper.resolveGenericParameters(this, genericParameters);

    //        // 解析基类。
    //        resolveBaseTypes();

    //        // 解析子类型。
    //        ResolveHelper.resolveChildMembers(this);
    //    }

    //    /// <summary>
    //    /// 解析当前成员内的基类和接口。
    //    /// </summary>
    //    private void resolveBaseTypes() {

    //        TypeReference typeReference = this.typeReference;

    //        if (baseTypes != null) {
    //            foreach (var baseType in baseTypes) {
    //                var baseTypeReference = baseType.resolveAsType(parentContainer, MemberUsage.type);
    //                if (baseTypeReference != null) {
    //                    switch (baseTypeReference.memberType) {
    //                        case MemberType.@interface:
    //                            if (!typeReference.addInterface(baseTypeReference)) {
    //                                Compiler.error(1, String.Format("当前类型已经声明了实现{0}", baseTypeReference.signature), baseType);
    //                                typeReference.baseType = baseTypeReference;
    //                            }
    //                            break;
    //                        default:
    //                            Compiler.error(1, String.Format("结构不能继承，结构只能实现接口（“{0}” 是{1}，不是接口）", baseTypeReference.fullName, baseTypeReference.memberType.getReadableName()), baseType);
    //                            break;
    //                    }
    //                }
    //            }
    //        }

    //        typeReference.baseType = PredefinedTypes.valueType;

    //    }

    //    public override void resolveBody() {

    //        // 解析注解。
    //        ResolveHelper.checkAnnotations(this);

    //        // 解析 new 关键字。
    //        ResolveHelper.checkNew(this);

    //        // 解析泛型参数。
    //        ResolveHelper.checkGenericParameters(this, genericParameters);

    //        // 解析继承列表。
    //        if (baseTypes != null) {

    //            // 继承的接口。
    //            ResolveHelper.checkInterfaces(this, false);

    //        }

    //        ResolveHelper.resolveChildBody(this);
    //    }

    //    ///// <summary>
    //    ///// 生成当前节点的代码。
    //    ///// </summary>
    //    ///// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //    //public override void emit(EmitContext context) {
    //    //    base.emit(context);
    //    //}


    //}

    ///// <summary>
    ///// 表示一个接口定义。
    ///// </summary>
    //public partial class InterfaceDefinition : TypeDefinition {

    //    /// <summary>
    //    /// 创建当前成员的引用。在创建引用前无法调用其它解析函数。
    //    /// </summary>
    //    /// <param name="container">要添加到的父容器引用。</param>
    //    public override void defineMember(MemberContainerReference container) {

    //        // 检查修饰符。
    //        ResolveHelper.checkModifiersOfTypes(this, Modifiers.ACCESSIBILITY | Modifiers.@new);
    //        ResolveHelper.setDefaultAccessibility(this);

    //        // 创建类型。
    //        ResolveHelper.defineType(this, container);
    //    }

    //    /// <summary>
    //    /// 解析当前成员相关的类型引用。在解析类型前无法解析任何主体。
    //    /// </summary>
    //    public override void resolveMember() {

    //        // 解析注解。
    //        ResolveHelper.resolveAnnotations(this);

    //        // 解析泛型参数。
    //        ResolveHelper.resolveGenericParameters(this, genericParameters);

    //        // 解析基类。
    //        resolveBaseTypes();

    //        // 解析子类型。
    //        ResolveHelper.resolveChildMembers(this);
    //    }

    //    /// <summary>
    //    /// 解析当前成员内的基类和接口。
    //    /// </summary>
    //    private void resolveBaseTypes() {

    //        TypeReference typeReference = this.typeReference;

    //        if (baseTypes != null) {
    //            foreach (var baseType in baseTypes) {
    //                var baseTypeReference = baseType.resolveAsType(parentContainer, MemberUsage.type);
    //                if (baseTypeReference != null) {
    //                    switch (baseTypeReference.memberType) {
    //                        case MemberType.@interface:
    //                            if (!typeReference.addInterface(baseTypeReference)) {
    //                                Compiler.error(1, String.Format("当前类型已经声明了实现{0}", baseTypeReference.signature), baseType);
    //                                typeReference.baseType = baseTypeReference;
    //                            }
    //                            break;
    //                        default:
    //                            Compiler.error(1, String.Format("接口只能从另一个接口继承（“{0}” 是{1}，不是接口）", baseTypeReference.fullName, baseTypeReference.memberType.getReadableName()), baseType);
    //                            break;
    //                    }
    //                }
    //            }
    //        }

    //        #region 检查循环继承关系

    //        if (typeReference.implementedTypes == null) {
    //            return;
    //        }

    //        var p = typeReference.implementedTypes;

    //        // 不是当前项目内定义的类不存在循环继承的关系。
    //        // 如果父类的父类还未解析完成，则不继续判断，等待解析父类时进行判断。
    //        if (p != null) {
    //            for (int i = 0; i < p.Count; i++) {
    //                if (!checkBaseTypeInternal(baseTypes[i], p[i], typeReference, p[i])) {
    //                    p.RemoveAt(i--);
    //                }
    //            }
    //        }

    //        #endregion

    //    }

    //    private static bool checkBaseTypeInternal(Expression baseTypeNode, TypeReference baseType, TypeReference typeReference, TypeReference currentType) {

    //        // 外部定义的接口不会出现循环继承。
    //        if (currentType.memberDefinition == null) {
    //            return false;
    //        }

    //        // 如果递归继承的类的子类时回到类自身，则出现错误。
    //        if (currentType == typeReference) {
    //            Compiler.error(1, String.Format("检测到“{0}”和“{1}”有循环继承关系", baseType.fullName, typeReference.fullName), baseTypeNode);
    //            return false;
    //        }

    //        // 继续遍历子类。
    //        if (currentType.implementedTypes != null) {
    //            foreach (var childType in currentType.implementedTypes) {
    //                if (!checkBaseTypeInternal(baseTypeNode, baseType, typeReference, childType)) {
    //                    return false;
    //                }
    //            }
    //        }

    //        return true;
    //    }

    //    public override void resolveBody() {

    //        // 解析注解。
    //        ResolveHelper.checkAnnotations(this);

    //        // 解析 new 关键字。
    //        ResolveHelper.checkNew(this);

    //        // 解析泛型参数。
    //        ResolveHelper.checkGenericParameters(this, genericParameters);

    //        // 解析继承列表。
    //        if (baseTypes != null) {

    //            var typeReference = this.typeReference;

    //            if (typeReference.implementedTypes != null) {
    //                int i = 0;
    //                foreach (var type in typeReference.implementedTypes) {
    //                    var node = baseTypes[i++];

    //                    // 继承类型必须达到当前类型的访问性。
    //                    if (!type.isAccessibleAs(memberReference)) {
    //                        Compiler.error(1, String.Format("基接口“{0}”的访问权限不能低于“{1}”", type.fullName, memberReference.fullName), node);
    //                        continue;
    //                    }

    //                    // 检查成员是否被否定。
    //                    ResolveHelper.checkDeprecated(type, node);

    //                }
    //            }

    //        }

    //    }

    //    ///// <summary>
    //    ///// 生成当前节点的代码。
    //    ///// </summary>
    //    ///// <param name="context">用于存储所有生成数据的上下文对象。</param>
    //    //public override void emit(EmitContext context) {
    //    //    base.emit(context);
    //    //}

    //}

    //#endregion

    //#endregion

}